diff --git a/.gitignore b/.gitignore
index fe066a9..f5b4078 100644
--- a/.gitignore
+++ b/.gitignore
@@ -42,3 +42,6 @@ docs
.claude
.mnt
.pi
+
+# Zed local settings (machine-local MCP tokens live here)
+.zed/settings.local.json
diff --git a/.zed/settings.json b/.zed/settings.json
index 98cddac..0e173b3 100644
--- a/.zed/settings.json
+++ b/.zed/settings.json
@@ -1,29 +1,38 @@
{
"show_completions_on_input": true,
- "languages": {
- "QML": {
- "colorize_brackets": true,
- "inlay_hints": {
- "show_background": true,
- "enabled": true
- },
- "show_whitespaces": "all",
- "show_completions_on_input": true,
- "always_treat_brackets_as_autoclosed": true,
- "format_on_save": "on",
- "language_servers": ["qmljs"]
- }
- },
- "lsp": {
- "qmljs": {
+ "context_servers": {
+ "linux-tracker": {
+ "url": "http://fwdesk.lab.internal:1984/mcp"
+ }
+ },
+ "languages": {
+ "QML": {
+ "colorize_brackets": true,
+ "inlay_hints": {
+ "show_background": true,
+ "enabled": true
+ },
+ "show_whitespaces": "all",
+ "show_completions_on_input": true,
+ "always_treat_brackets_as_autoclosed": true,
+ "format_on_save": "on",
+ "language_servers": [
+ "qmljs"
+ ]
+ }
+ },
+ "lsp": {
+ "qmljs": {
"enable_lsp_tasks": true,
- "binary": {
- "path": "qmlls",
- "arguments": ["-E"]
- },
- "initialization_options": {
- "buildDir": "."
- }
- }
- }
+ "binary": {
+ "path": "qmlls",
+ "arguments": [
+ "-E"
+ ]
+ },
+ "initialization_options": {
+ "buildDir": "."
+ }
+ }
+ }
}
diff --git a/flake.lock b/flake.lock
index 1076f51..06717e9 100644
--- a/flake.lock
+++ b/flake.lock
@@ -1088,11 +1088,11 @@
"treefmt-nix": "treefmt-nix_3"
},
"locked": {
- "lastModified": 1791570912,
- "narHash": "sha256-qWpBgsVYqmK3vKtoUm7/w1B2mOwHkridUyc1ESAooVg=",
+ "lastModified": 1793031979,
+ "narHash": "sha256-PKMdT/idOFtPwj03PzWzIO4prgPCtMsG1ig1FUlCeTM=",
"ref": "refs/heads/main",
- "rev": "30427e3975637593c995d357815b99aecb512cfa",
- "revCount": 43,
+ "rev": "ed558a196fcbc65c1af82fb0f54fdd6773c76b66",
+ "revCount": 47,
"type": "git",
"url": "ssh://gitea@gitea.app.internal:22/ari/hermenix.git"
},
diff --git a/flake.nix b/flake.nix
index 33ae1a7..98bee69 100644
--- a/flake.nix
+++ b/flake.nix
@@ -181,6 +181,8 @@
linux-tracker-peer-bigbox2 = ./secrets/linux-tracker-peer-bigbox2.age;
linux-tracker-peer-terra1 = ./secrets/linux-tracker-peer-terra1.age;
scrypted-envs = ./secrets/scrypted-envs.age;
+ robots-shared = ./secrets/robots-shared.age;
+ robots-sibli = ./secrets/robots-sibli.age;
};
inherit
hyprlauncher
diff --git a/hosts/hl-fwdesk/networking.nix b/hosts/hl-fwdesk/networking.nix
index ca6e7cf..d60d110 100644
--- a/hosts/hl-fwdesk/networking.nix
+++ b/hosts/hl-fwdesk/networking.nix
@@ -2,8 +2,5 @@
{
services.tailscale.enable = true;
- systemd.network.wait-online.ignoredInterfaces = [
- "hermes-br"
- "vm-hermes"
- ];
+ systemd.network.wait-online.enable = false;
}
diff --git a/hosts/hl-fwdesk/services/robotnix.nix b/hosts/hl-fwdesk/services/robotnix.nix
index 7f26001..1f003d6 100644
--- a/hosts/hl-fwdesk/services/robotnix.nix
+++ b/hosts/hl-fwdesk/services/robotnix.nix
@@ -1,6 +1,8 @@
-{ config, ... }:
+{ config, lib, skyg-secrets, ... }:
let
apps = config.skyg.internalNetworkingMap.apps;
+ robotSecrets = [ "robots-shared" "robots-sibli" ];
+ secret = name: config.age.secrets.${name}.path;
ports = {
ollama = 11434;
ds4 = 8000;
@@ -8,6 +10,12 @@ let
};
in
{
+ age.secrets = lib.genAttrs robotSecrets (name: {
+ file = skyg-secrets.${name};
+ owner = "root";
+ mode = "0400";
+ });
+
skyg.nixos.server.robotnix = {
enable = true;
externalInterface = "enp191s0";
@@ -17,23 +25,40 @@ in
internet = "all";
hostAccess = [
{ port = ports.ollama; }
- { port = ports.tracker; }
];
lanAccess = [ ];
};
- robots.genix = {
- id = 1;
- address = apps.genix.ip;
+ # A Hermes agent in every robot.
+ hermes = {
+ enable = true;
+ environmentFiles = [ (secret "robots-shared") ];
+ };
+
+ robots.sibli = {
+ id = 2;
+ address = apps.sibli.ip;
cpus = { min = 1; max = 4; };
- memory = { min = "8G"; max = "16G"; };
+ memory = { min = "2G"; max = "16G"; };
disk = { rootSize = "100G"; homeSize = "60G"; };
- seed.configuration = ./robotnix/genix.nix;
- access = { };
- git = {
- enable = true;
- remoteUrl = "gitea@gitea.app.internal:Hermenix/genix.git";
+ seed.configuration = ./robotnix/sibli.nix;
+ hermes = {
+ name = "Siblix";
+ environmentFiles = [ (secret "robots-sibli") ];
+ settings.model = {
+ provider = "anthropic";
+ default = "claude-haiku-5-5";
+ };
};
+ allowDocker = true;
+ allowTun = true;
+ ephemeral = true;
+ persist = [
+ "/var/lib/tailscale"
+ "/var/lib/docker"
+ ];
+ access = { };
+ git.enable = false;
};
};
}
diff --git a/hosts/hl-fwdesk/services/robotnix/genix.nix b/hosts/hl-fwdesk/services/robotnix/genix.nix
deleted file mode 100644
index 1c4b538..0000000
--- a/hosts/hl-fwdesk/services/robotnix/genix.nix
+++ /dev/null
@@ -1,28 +0,0 @@
-# genix's starting NixOS config (a robotnix seed, not a host module).
-#
-# The host copies this into the robot's /etc/nixos on first install and on
-# `robotnix reseed`. After that the robot owns it. Inside the robot:
-# sudo nixos-rebuild switch --flake /etc/nixos
-# Host-managed basics (network, ssh, user) live in /etc/nixos/robotnix.nix.
-{ pkgs, ... }:
-{
- # The user has no password; ssh keys only.
- security.sudo.wheelNeedsPassword = false;
-
- environment.systemPackages = with pkgs; [
- git
- vim
- curl
- htop
- claude-code
- goose-cli
- pi-coding-agent
- devenv
- ];
- nixpkgs.config.allowUnfree = true;
- nix.gc = {
- automatic = true;
- dates = "weekly";
- options = "--delete-older-than 14d";
- };
-}
diff --git a/hosts/hl-fwdesk/services/robotnix/sibli.nix b/hosts/hl-fwdesk/services/robotnix/sibli.nix
new file mode 100644
index 0000000..f1ff2aa
--- /dev/null
+++ b/hosts/hl-fwdesk/services/robotnix/sibli.nix
@@ -0,0 +1,33 @@
+# sibli is ephemeral: root resets to this config on every start, so change
+# things here (then rebuild the host), not inside the robot.
+{ pkgs, ... }:
+{
+ # The user has no password; ssh keys only.
+ security.sudo.wheelNeedsPassword = false;
+
+ environment.systemPackages = with pkgs; [
+ git
+ vim
+ curl
+ htop
+ claude-code
+ devenv
+ zellij
+ ];
+ nixpkgs.config.allowUnfree = true;
+
+ # Docker + compose. Needs allowDocker = true on the host.
+ virtualisation.docker.enable = true;
+ users.users.ari.extraGroups = [ "docker" ];
+
+ # Own tailnet machine. Needs allowTun = true on the host.
+ # Log in once: sudo tailscale up (state is kept via persist on the host)
+ services.tailscale.enable = true;
+ services.tailscale.openFirewall = true;
+ networking.firewall.trustedInterfaces = [ "tailscale0" ];
+ nix.gc = {
+ automatic = true;
+ dates = "weekly";
+ options = "--delete-older-than 14d";
+ };
+}
diff --git a/modules/main.nix b/modules/main.nix
index 8ec9288..761cbc6 100644
--- a/modules/main.nix
+++ b/modules/main.nix
@@ -111,8 +111,8 @@ in
public-gitea = { ip = "10.0.101.9"; };
immich = { ip = "10.0.101.10"; };
immich-ml = { ip = "10.0.101.11"; };
- genix = { ip = "10.0.101.12"; };
gilix = { ip = "10.0.101.13"; };
+ sibli = { ip = "10.0.101.14"; };
jellyfin = { ip = "10.0.101.5"; };
nvr = { ip = "10.0.101.6"; };
portainer = { ip = "10.0.101.241"; };
diff --git a/modules/nixos/server/robotnix/ABOUTME.md b/modules/nixos/server/robotnix/ABOUTME.md
index 8097986..75a05d4 100644
--- a/modules/nixos/server/robotnix/ABOUTME.md
+++ b/modules/nixos/server/robotnix/ABOUTME.md
@@ -56,6 +56,14 @@ One routed virtual switch:
does the per-robot filtering before `nixos-fw` (priority filter - 10). IPv6
from robots is dropped (`host0` is IPv4-only). Inbound from the LAN to a
robot is open on every port — make your own decisions inside the robot.
+- Guards in the same table, so other modules' NAT can't reroute robot
+ traffic (hermenix once DNAT'd any-destination traffic on some ports into
+ its VM):
+ - a connection meant for a robot IP that leaves anywhere but the switch,
+ or lands on the host itself, is dropped (`ct original ip daddr`; replies
+ are untouched via `ct direction original`);
+ - a robot's own new connection that was DNAT'd is dropped. The robot DNS
+ redirect still works: it goes to the host (input), not forward.
- Per-robot dnsmasq on the host (port 5300+id) is the robot's only resolver:
all port 53 is DNAT'd to it, DoT is dropped. The robot cannot change its
resolv.conf meaningfully; it cannot touch the host's nftables/networkd.
@@ -88,6 +96,86 @@ if origin exists) runs on `git.interval` (`daily` default). The robot needs the
remote reachable (e.g. through `lanAccess`) and its own credentials if the
remote is private.
+## Ephemeral robots (opt-in)
+
+`ephemeral = true` resets root to a clean copy of the seed on every start
+(host boot, `robotnix restart`, or a reboot inside). Only `/home` survives.
+
+- The seed step saves the fresh root as a read-only subvolume
+ `/pristine` before the robot first boots, plus `pristine.id` (hash of
+ the seed system and the files it installs).
+- Before each start, `robotnix--reset.service` unmounts root, swaps
+ `/root` for a snapshot of `pristine`, and remounts (about a second).
+ It is its own oneshot (no `RemainAfterExit`, so every robot start re-runs
+ it) because the robot unit's `DevicePolicy=closed` blocks the loop devices
+ the mount needs.
+- When the seed changes, the storage step sees a different id on the next
+ host switch, wipes root, and the seed step reinstalls (a few minutes).
+- `persist = [ "/var/lib/..." ]` keeps folders: stored in `/home/.persist`
+ inside the home image and bind-mounted at their usual path. SSH host keys
+ always go to `/home/.persist/ssh`, so they don't change each boot.
+- The robot still has its own writable store, so `nix`/`devenv` work until
+ the next restart. Changes go through `seed.configuration` on the host.
+- Snapshots and `restore` cover home only; `reseed` drops `pristine` too.
+- git-sync can't work (fresh repo each start): eval asserts it is off.
+
+## Hermes in every robot (opt-in)
+
+`hermes.enable` (shared) runs one Hermes agent per robot with the upstream
+`services.hermes-agent` module; `robots..hermes.enable` can opt out.
+
+- The robot's flake gets a `hermes-agent` input pinned to the host's locked
+ rev, and the host's seed build includes the same module.
+- Host-managed: `hermes.settings` (shared + robot, deep-merged) goes to
+ config.yaml; `hermes.name` writes SOUL.md ("You are , a Hermes-based
+ agent ...") on every boot; null keeps the stock identity.
+- Secrets: `hermes.environmentFiles` (shared + robot, KEY=value, e.g. agenix)
+ are passed with `--load-credential` and loaded by the `hermes-agent` unit
+ from `/run/credentials/@system/robotnix-hermes-` (later files win). No
+ file ownership games with the user namespace. Restart the robot after a
+ secret changes.
+- The `hermes` user/group have a fixed id (870) so kept files stay owned
+ right across reinstalls; the login user is in the `hermes` group and has
+ the `hermes` CLI.
+- Ephemeral robots keep only `cron/`, `memories/` and `skills/` of
+ `/var/lib/hermes/.hermes` (added to `persist` automatically). Sessions,
+ logs, OAuth logins and pairings reset each start: use API keys and
+ `*_ALLOWED_USERS` env vars instead.
+- Gateway API (`hermes.gateway`, on by default, port 8642): the host sets
+ `services.hermes-agent.environment` (`API_SERVER_ENABLED`, `_HOST=0.0.0.0`,
+ `_PORT`, `_MODEL_NAME` = `hermes.name` or the robot name). These go to
+ `$HERMES_HOME/.env`, which beats the same names in the secrets. Each
+ robot's secrets need `API_SERVER_KEY`, or the API server won't start.
+- Dashboard (`hermes.dashboard`, on by default, port 80):
+ `backend.mode = "dashboard"` on 0.0.0.0, run as `hermes-backend.service`
+ with the same secret files, plus `CAP_NET_BIND_SERVICE` when the port is
+ below 1024. A non-loopback dashboard needs a login in the secrets:
+ `HERMES_DASHBOARD_BASIC_AUTH_USERNAME`, `..._PASSWORD_HASH` (or
+ `..._PASSWORD`) and `..._SECRET` (keeps sessions across restarts). Without
+ one it exits and systemd keeps restarting it; the gateway keeps working.
+ Port 80 may clash with the robot's own compose stacks: change the port.
+- Both: top-level `enable/port/openFirewall`, robots override any of them
+ (null = follow). `openFirewall` opens the TCP port in the robot's own
+ firewall. Eval asserts the two don't share a port.
+- Existing robots only get Hermes (and gateway/dashboard changes) after
+ `robotnix reseed` (flake.nix and robotnix.nix are written at install).
+ Ephemeral robots pick changes up on the next host switch.
+
+## Docker and Tailscale (opt-in, host side only)
+
+These options only change what the host allows. Turn the service on in the
+robot's own config (e.g. its `seed.configuration`).
+
+- `allowDocker`: nspawn gets `--system-call-filter=add_key keyctl bpf`
+ (blocked by default, Docker needs them). Docker runs inside the robot's user
+ namespace, so images using UIDs above 65535 won't run.
+- `allowTun`: `/dev/net/tun` is bound in and allowed on the unit
+ (`DevicePolicy=closed` blocks it otherwise). Used for tailscale: the robot
+ is its own tailnet machine, log in once inside with `sudo tailscale up`.
+ Direct LAN paths to other tailnet peers hit the private-range drop, so it
+ uses public endpoints or DERP.
+- Both apply on the next robot restart; no reseed needed.
+
## The `robotnix` CLI
Nushell script (`pkgs.writers.writeNuBin`), part of this module:
diff --git a/modules/nixos/server/robotnix/default.nix b/modules/nixos/server/robotnix/default.nix
index 7e1893a..28929ea 100644
--- a/modules/nixos/server/robotnix/default.nix
+++ b/modules/nixos/server/robotnix/default.nix
@@ -95,6 +95,74 @@ let
};
};
+ # Hermes options used by both the shared and the per-robot block.
+ hermesSettings = mkOption {
+ type = types.attrsOf types.anything;
+ default = { };
+ example = {
+ model.provider = "openrouter";
+ };
+ description = "Hermes config.yaml settings. Shared and robot settings are deep-merged (robot wins).";
+ };
+ hermesEnvFiles = mkOption {
+ type = types.listOf types.str;
+ default = [ ];
+ example = [ "/run/agenix/robots-shared" ];
+ description = ''
+ Host paths of KEY=value secret files (e.g. agenix). Passed to the robot
+ as container credentials and loaded into Hermes's environment. Read at
+ robot start: restart the robot after changing one.
+ '';
+ };
+
+ # Gateway API / dashboard options. The top level sets the values; each
+ # robot can override one (null = follow the top level).
+ hermesService =
+ { what
+ , port
+ , robot
+ , enableText
+ ,
+ }:
+ let
+ opt =
+ type: default: description:
+ mkOption {
+ type = if robot then types.nullOr type else type;
+ default = if robot then null else default;
+ description = if robot then "${description} null: follow hermes.${what}." else description;
+ };
+ in
+ {
+ enable = opt types.bool true enableText;
+ port = opt types.port port "Port on the robot's address.";
+ openFirewall = opt types.bool true "Open the port in the robot's firewall.";
+ };
+ hermesGateway =
+ robot:
+ hermesService {
+ inherit robot;
+ what = "gateway";
+ port = 8642;
+ enableText = ''
+ Turn on the gateway's OpenAI-compatible API on all of the robot's
+ addresses. The robot's secrets need API_SERVER_KEY, or it won't start.
+ '';
+ };
+ hermesDashboard =
+ robot:
+ hermesService {
+ inherit robot;
+ what = "dashboard";
+ port = 80;
+ enableText = ''
+ Run the Hermes dashboard on all of the robot's addresses. The robot's
+ secrets need a login (HERMES_DASHBOARD_BASIC_AUTH_USERNAME,
+ HERMES_DASHBOARD_BASIC_AUTH_PASSWORD_HASH and
+ HERMES_DASHBOARD_BASIC_AUTH_SECRET), or the dashboard exits.
+ '';
+ };
+
robot = types.submodule (
{ name, ... }:
{
@@ -165,6 +233,61 @@ let
description = "/home image. Grows on restart if raised.";
};
};
+ ephemeral = mkOption {
+ type = types.bool;
+ default = false;
+ description = ''
+ Reset root to a clean copy of the seed on every start. Only /home
+ (and `persist`) survives. Changes go through seed.configuration on
+ the host. Snapshots then cover /home only.
+ '';
+ };
+ persist = mkOption {
+ type = types.listOf (types.strMatching "/[^:[:space:]]+");
+ default = [ ];
+ example = [ "/var/lib/tailscale" ];
+ description = ''
+ Folders kept across resets. Stored in /home/.persist inside the
+ home image and mounted at their usual path.
+ '';
+ };
+ hermes = {
+ enable = mkOption {
+ type = types.nullOr types.bool;
+ default = null;
+ description = "Run Hermes in this robot. null: follow hermes.enable.";
+ };
+ name = mkOption {
+ type = types.nullOr types.str;
+ default = null;
+ example = "Siblibot";
+ description = ''
+ Name the agent gives itself ("I am Siblibot, a Hermes-based
+ agent"). Written to SOUL.md by the host on every boot. null keeps
+ the stock Hermes identity.
+ '';
+ };
+ settings = hermesSettings;
+ environmentFiles = hermesEnvFiles;
+ gateway = hermesGateway true;
+ dashboard = hermesDashboard true;
+ };
+ allowDocker = mkOption {
+ type = types.bool;
+ default = false;
+ description = ''
+ Allow the syscalls Docker needs (add_key, keyctl, bpf). Host side
+ only: enable Docker in the robot's own config.
+ '';
+ };
+ allowTun = mkOption {
+ type = types.bool;
+ default = false;
+ description = ''
+ Pass /dev/net/tun into the robot (e.g. for tailscale). Host side
+ only: enable tailscale in the robot's own config.
+ '';
+ };
access = mkOption {
type = tier;
default = { };
@@ -195,7 +318,7 @@ let
remoteUrl = mkOption {
type = types.nullOr types.str;
default = null;
- example = "git@github.com:ari/genix.git";
+ example = "git@github.com:ari/myrobot.git";
description = ''
Origin for the flake repo, set on first install. null = no remote:
the timer commits locally but never pushes.
@@ -292,6 +415,14 @@ in
description = "Tier applied to every robot.";
};
+ hermes = {
+ enable = mkEnableOption "a Hermes agent in every robot (robots can opt out)";
+ settings = hermesSettings;
+ environmentFiles = hermesEnvFiles;
+ gateway = hermesGateway false;
+ dashboard = hermesDashboard false;
+ };
+
robots = mkOption {
type = types.attrsOf robot;
default = { };
@@ -343,6 +474,23 @@ in
assertion = both "allowedCidrs" "blockedCidrs" == [ ];
message = "robotnix: ${r.name} both allows and blocks: ${toString (both "allowedCidrs" "blockedCidrs")}.";
}
+ {
+ assertion = !(r.ephemeral && r.git.enable);
+ message = "robotnix: ${r.name} is ephemeral, so git-sync can't work (fresh repo every start). Set git.enable = false.";
+ }
+ {
+ assertion = lib.all (p: !(lib.hasPrefix "/home" p || lib.hasPrefix "/nix" p || p == "/")) r.persist;
+ message = "robotnix: ${r.name}'s persist folders can't be /, or under /home or /nix.";
+ }
+ {
+ assertion =
+ let
+ g = r.hermes.gateway;
+ d = r.hermes.dashboard;
+ in
+ !(r.hermes.enable && g.enable && d.enable && g.port == d.port);
+ message = "robotnix: ${r.name}'s Hermes gateway and dashboard can't share port ${toString r.hermes.gateway.port}.";
+ }
{
assertion = r.cpus.min <= r.cpus.max;
message = "robotnix: ${r.name} cpus.min must be <= cpus.max.";
diff --git a/modules/nixos/server/robotnix/helpers.nix b/modules/nixos/server/robotnix/helpers.nix
index 567c5b6..e2226f0 100644
--- a/modules/nixos/server/robotnix/helpers.nix
+++ b/modules/nixos/server/robotnix/helpers.nix
@@ -48,30 +48,68 @@ let
hostAccess = both (t: t.hostAccess);
};
- mkRobot = name: r: {
- inherit name;
- inherit (r)
- id
- address
- autoStart
- privateUsers
- cpus
- memory
- disk
- snapshots
- seed
- user
- authorizedKeys
- git
- ;
- nft = nftName name;
- port = "vb-${name}";
- dnsPort = 5300 + r.id;
- base = "${cfg.baseDir}/${name}";
- run = "/run/robotnix/${name}";
- unit = "robotnix-${name}";
- access = mergeAccess r.access;
- };
+ # Hermes's home inside a robot (the upstream module's default).
+ hermesHome = "/var/lib/hermes/.hermes";
+
+ # Shared Hermes block + the robot's own. Robot settings win.
+ mergeHermes =
+ r:
+ let
+ s = cfg.hermes;
+ pick = a: b: if a != null then a else b;
+ # Robot values that are null follow the shared ones.
+ follow = what: lib.mapAttrs (k: v: pick r.${what}.${k} v) s.${what};
+ in
+ {
+ enable = pick r.enable s.enable;
+ inherit (r) name;
+ settings = lib.recursiveUpdate s.settings r.settings;
+ environmentFiles = lib.unique (s.environmentFiles ++ r.environmentFiles);
+ gateway = follow "gateway";
+ dashboard = follow "dashboard";
+ };
+
+ mkRobot = name: r:
+ let
+ hermes = mergeHermes r.hermes;
+ in
+ {
+ inherit name hermes;
+ inherit (r)
+ id
+ address
+ autoStart
+ privateUsers
+ cpus
+ memory
+ disk
+ snapshots
+ seed
+ user
+ authorizedKeys
+ git
+ allowDocker
+ allowTun
+ ephemeral
+ ;
+ # Ephemeral + Hermes: keep only its cron jobs, memories and skills.
+ persist =
+ r.persist
+ ++ lib.optionals (r.ephemeral && hermes.enable) (
+ map (d: "${hermesHome}/${d}") [
+ "cron"
+ "memories"
+ "skills"
+ ]
+ );
+ nft = nftName name;
+ port = "vb-${name}";
+ dnsPort = 5300 + r.id;
+ base = "${cfg.baseDir}/${name}";
+ run = "/run/robotnix/${name}";
+ unit = "robotnix-${name}";
+ access = mergeAccess r.access;
+ };
robots = lib.mapAttrs mkRobot cfg.robots;
in
@@ -81,6 +119,7 @@ in
nftName
nixStr
robots
+ hermesHome
;
robotList = lib.attrValues robots;
}
diff --git a/modules/nixos/server/robotnix/network.nix b/modules/nixos/server/robotnix/network.nix
index 6531972..0b634c1 100644
--- a/modules/nixos/server/robotnix/network.nix
+++ b/modules/nixos/server/robotnix/network.nix
@@ -103,6 +103,9 @@ let
vmap = prefix: set (map (r: "${r.address} : jump ${prefix}_${r.nft}") rs);
+ # Every robot's own address.
+ robotIps = set (map (r: r.address) rs);
+
# Host-side dnsmasq per robot. It is the robot's only resolver.
dnsConf =
r:
@@ -226,9 +229,14 @@ lib.mkIf cfg.enable {
chain forward {
type filter hook forward priority filter - 10; policy accept;
+ # Traffic meant for a robot goes to that robot, nowhere else (e.g.
+ # another module's DNAT). Replies are not touched.
+ ct direction original ct original ip daddr ${robotIps} oifname != "${br}" drop
iifname "${br}" ct state established,related accept
iifname "${br}" meta nfproto ipv6 drop
oifname "${br}" meta nfproto ipv6 drop
+ # A robot's own connection that someone redirected elsewhere.
+ iifname "${br}" ct status dnat drop
iifname "${br}" ip saddr vmap ${vmap "out"}
iifname "${br}" drop
# Inbound from the LAN to robots: open.
@@ -236,6 +244,8 @@ lib.mkIf cfg.enable {
chain input {
type filter hook input priority filter - 10; policy accept;
+ # Traffic meant for a robot, redirected to the host itself.
+ ct direction original ct original ip daddr ${robotIps} drop
iifname != "${br}" accept
ct state established,related accept
meta nfproto ipv6 drop
diff --git a/modules/nixos/server/robotnix/robotnix.nu b/modules/nixos/server/robotnix/robotnix.nu
index c38bceb..6d84722 100644
--- a/modules/nixos/server/robotnix/robotnix.nu
+++ b/modules/nixos/server/robotnix/robotnix.nu
@@ -53,6 +53,12 @@ def stop-robot [r: record] {
^systemctl stop $u.robot $u.seed $u.storage
}
+# What a snapshot covers. Ephemeral robots reset root on every start, so
+# only home is worth keeping.
+def parts [r: record] {
+ if $r.ephemeral { [home] } else { [root home] }
+}
+
# Snapshot ids are "-", e.g. 2026-10-23T14-00-00-auto.
def snapshot-list [r: record] {
let dir = $"($r.base)/snapshots"
@@ -71,15 +77,15 @@ def snapshot-list [r: record] {
}
}
-# Freeze both filesystems (if mounted), snapshot both subvolumes, thaw.
+# Freeze the filesystems (if mounted), snapshot the subvolumes, thaw.
def take-snapshot [r: record, kind: string] {
let id = $"(stamp)-($kind)"
let dest = $"($r.base)/snapshots/($id)"
mkdir $dest
- let mounts = ([$"($r.run)/root" $"($r.run)/home"] | where {|m| is-mounted $m })
+ let mounts = (parts $r | each {|p| $"($r.run)/($p)" } | where {|m| is-mounted $m })
let err = (try {
for m in $mounts { ^fsfreeze -f $m }
- for sub in [root home] {
+ for sub in (parts $r) {
^btrfs subvolume snapshot -r $"($r.base)/($sub)" $"($dest)/($sub)"
}
null
@@ -135,6 +141,7 @@ def "main list" [] {
root: (disk-usage $"($r.run)/root")
home: (disk-usage $"($r.run)/home")
snapshots: (snapshot-list $r | length)
+ ephemeral: $r.ephemeral
}
}
}
@@ -204,11 +211,11 @@ def "main restore" [
need-root
let r = (robot $name)
let subs = if $only == null {
- [root home]
- } else if $only in [root home] {
+ parts $r
+ } else if $only in (parts $r) {
[$only]
} else {
- error make { msg: "--only must be root or home" }
+ error make { msg: $"--only must be one of: (parts $r | str join ', ')" }
}
let src = $"($r.base)/snapshots/($id)"
for sub in $subs {
@@ -242,6 +249,11 @@ def "main reseed" [
stop-robot $r
let saved = (take-snapshot $r "pre-reseed")
rm -f $"($r.base)/root/root.img"
+ # Ephemeral: drop the clean root too, so the next start reinstalls.
+ if $r.ephemeral {
+ rm -f $"($r.base)/pristine.id"
+ if ($"($r.base)/pristine" | path exists) { ^btrfs subvolume delete $"($r.base)/pristine" }
+ }
if $wipe_home { rm -f $"($r.base)/home/home.img" }
^systemctl start (units $r).robot
print $"($name) reseeded. Undo with: robotnix restore ($name) ($saved)"
diff --git a/modules/nixos/server/robotnix/robots.nix b/modules/nixos/server/robotnix/robots.nix
index 9183d1b..8743c5e 100644
--- a/modules/nixos/server/robotnix/robots.nix
+++ b/modules/nixos/server/robotnix/robots.nix
@@ -9,6 +9,7 @@
{ config
, lib
, pkgs
+, hermes-agent
, ...
}:
let
@@ -28,6 +29,29 @@ let
if rev != null then builtins.unsafeDiscardStringContext rev else "nixos-unstable";
keys = r: lib.concatMapStringsSep " " h.nixStr r.authorizedKeys;
+
+ # Ephemeral robots: kept folders live here, inside the home image.
+ persistDir = "/home/.persist";
+
+ # Robots pin the same hermes-agent revision the host has locked.
+ hermesRef = hermes-agent.rev or "main";
+
+ # Fixed ids so kept Hermes files stay owned right across reinstalls.
+ hermesId = 870;
+
+ # Secrets reach Hermes as container credentials, one per file.
+ hermesCreds = r: lib.imap0 (i: f: { id = "robotnix-hermes-${toString i}"; file = f; }) r.hermes.environmentFiles;
+
+ # Stock Hermes identity, with the robot's own name.
+ soul =
+ name:
+ "You are ${name}, a Hermes-based agent. Be direct: match the length of your reply to the weight of "
+ + "the ask — a one-line question gets a one-line answer, and finished work gets a short report of what "
+ + "changed, what's verified, and what's left, never a replay of the process. No filler (\"Great question,\" "
+ + "\"I'd be happy to\"), no restating the request back, no re-summarizing what you already said, no narrating "
+ + "tool calls the user can see. Plain claims over adjectives; when unsure, say so plainly. Agree because it's "
+ + "right, not because the user said it. Depth is earned — give it when the user asks for detail, teaches, or "
+ + "the stakes demand it, not by default.\n";
tz = lib.optionalString
(
config.time.timeZone != null
@@ -36,6 +60,20 @@ let
# The host-owned part of the robot's config -> /etc/nixos/robotnix.nix.
robotnixNix =
r:
+ let
+ gw = r.hermes.gateway;
+ db = r.hermes.dashboard;
+ gwOn = r.hermes.enable && gw.enable;
+ dbOn = r.hermes.enable && db.enable;
+ openPorts = lib.optional (gwOn && gw.openFirewall) gw.port ++ lib.optional (dbOn && db.openFirewall) db.port;
+ envFiles = "[ ${lib.concatMapStringsSep " " (c: h.nixStr "/run/credentials/@system/${c.id}") (hermesCreds r)} ]";
+ gwEnv = {
+ API_SERVER_ENABLED = "true";
+ API_SERVER_HOST = "0.0.0.0";
+ API_SERVER_PORT = toString gw.port;
+ API_SERVER_MODEL_NAME = if r.hermes.name != null then r.hermes.name else r.name;
+ };
+ in
builtins.toFile "robotnix-${r.name}.nix" ''
# Generated by robotnix on the host (first install / reseed, or a host
# rebuild if you changed the robot's host-side settings).
@@ -70,12 +108,45 @@ let
};
users.users.${h.nixStr r.user} = {
isNormalUser = true;
- extraGroups = [ "wheel" ];
+ extraGroups = [ "wheel" ${lib.optionalString r.hermes.enable ''"hermes" ''}];
openssh.authorizedKeys.keys = [ ${keys r} ];
};
users.users.root.openssh.authorizedKeys.keys = [ ${keys r} ];
${tz}
system.stateVersion = ${h.nixStr r.seed.stateVersion};
+ ${lib.optionalString r.hermes.enable ''
+ # Hermes agent, managed by the host (robotnix hermes options).
+ services.hermes-agent = {
+ enable = true;
+ addToSystemPackages = true;
+ settings = builtins.fromJSON ${h.nixStr (builtins.toJSON r.hermes.settings)};
+ ${lib.optionalString (r.hermes.name != null) ''
+ hermesHomeFiles."SOUL.md" = ${h.nixStr (soul r.hermes.name)};
+ ''}
+ ${lib.optionalString gwOn ''environment = { ${lib.concatStringsSep " " (lib.mapAttrsToList (k: v: "${k} = ${h.nixStr v};") gwEnv)} }; # gateway API, key from the secrets''}
+ ${lib.optionalString dbOn ''backend = { mode = "dashboard"; host = "0.0.0.0"; port = ${toString db.port}; }; # login from the secrets''}
+ };
+ users.users.hermes.uid = ${toString hermesId};
+ users.groups.hermes.gid = ${toString hermesId};
+ # The module doesn't make skills/ (kept on ephemeral robots).
+ systemd.tmpfiles.rules = [ "d ${h.hermesHome}/skills 2770 hermes hermes - -" ];
+ # Secrets: container credentials from the host, read at start.
+ systemd.services.hermes-agent.serviceConfig.EnvironmentFile = ${envFiles};
+ ${lib.optionalString dbOn ''systemd.services.hermes-backend.serviceConfig.EnvironmentFile = ${envFiles};''}
+ ${lib.optionalString (dbOn && db.port < 1024) ''
+ # Ports below 1024 need this as the hermes user.
+ systemd.services.hermes-backend.serviceConfig.AmbientCapabilities = [ "CAP_NET_BIND_SERVICE" ];
+ ''}
+ ${lib.optionalString (openPorts != [ ]) ''networking.firewall.allowedTCPPorts = [ ${lib.concatMapStringsSep " " toString openPorts} ];''}
+ ''}
+ ${lib.optionalString r.ephemeral ''
+ # Ephemeral robot: root resets on every start. Keep the ssh host
+ # keys in /home so they don't change each boot.
+ services.openssh.hostKeys = [
+ { type = "ed25519"; path = "${persistDir}/ssh/ssh_host_ed25519_key"; }
+ { type = "rsa"; bits = 4096; path = "${persistDir}/ssh/ssh_host_rsa_key"; }
+ ];
+ ''}
${lib.optionalString r.git.enable ''
# git-tracking your flake: auto-commit, and push when a remote is set.
environment.systemPackages = [ pkgs.git ];
@@ -113,9 +184,14 @@ let
# sudo nixos-rebuild switch --flake /etc/nixos
{
inputs.nixpkgs.url = "github:NixOS/nixpkgs/${nixpkgsRef}";
- outputs = { nixpkgs, ... }: {
+ ${lib.optionalString r.hermes.enable ''inputs.hermes-agent.url = "github:NousResearch/hermes-agent/${hermesRef}";''}
+ outputs = { nixpkgs, ... }@inputs: {
nixosConfigurations.${h.nixStr r.name} = nixpkgs.lib.nixosSystem {
- modules = [ ./robotnix.nix ./configuration.nix ];
+ modules = [
+ ./robotnix.nix
+ ./configuration.nix
+ ${lib.optionalString r.hermes.enable "inputs.hermes-agent.nixosModules.default"}
+ ];
};
};
}
@@ -132,24 +208,54 @@ let
modules = [
(robotnixNix r)
r.seed.configuration
- ];
+ ]
+ ++ lib.optional r.hermes.enable hermes-agent.nixosModules.default;
}).config.system.build.toplevel;
+ # Ephemeral robots: fingerprint of everything the seed installs. When it
+ # changes, the clean root is rebuilt.
+ seedId =
+ r:
+ builtins.hashString "sha256" (
+ lib.concatStringsSep " " [
+ "${seedSystem r}"
+ "${flakeNix r}"
+ "${robotnixNix r}"
+ "${r.seed.configuration}"
+ ]
+ );
+
storageStart =
r:
- pkgs.writeShellScript "${r.unit}-storage-start" ''
- set -euo pipefail
- base=${r.base}
- mkdir -p ${cfg.baseDir}
- if [ "$(stat -f -c %T ${cfg.baseDir})" != btrfs ]; then
- echo "robotnix: ${cfg.baseDir} must be on btrfs (needed for snapshots)" >&2
- exit 1
- fi
- for sub in "$base" "$base/root" "$base/home" "$base/snapshots"; do
- [ -d "$sub" ] || btrfs subvolume create "$sub"
- done
- # No copy-on-write for the images (only affects new files).
- chattr +C "$base/root" "$base/home"
+ pkgs.writeShellScript "${r.unit}-storage-start" (
+ ''
+ set -euo pipefail
+ base=${r.base}
+ mkdir -p ${cfg.baseDir}
+ if [ "$(stat -f -c %T ${cfg.baseDir})" != btrfs ]; then
+ echo "robotnix: ${cfg.baseDir} must be on btrfs (needed for snapshots)" >&2
+ exit 1
+ fi
+ for sub in "$base" "$base/root" "$base/home" "$base/snapshots"; do
+ [ -d "$sub" ] || btrfs subvolume create "$sub"
+ done
+ # No copy-on-write for the images (only affects new files).
+ chattr +C "$base/root" "$base/home"
+ ''
+ + lib.optionalString r.ephemeral ''
+ # Ephemeral: seed changed (or first run) -> wipe root so the seed step
+ # reinstalls and saves a new clean root.
+ if ! mountpoint -q ${r.run}/root \
+ && [ "$(cat "$base/pristine.id" 2>/dev/null)" != ${seedId r} ]; then
+ echo "robotnix: seed for ${r.name} changed, reinstalling"
+ rm -f "$base/pristine.id"
+ if [ -d "$base/pristine" ]; then btrfs subvolume delete "$base/pristine"; fi
+ btrfs subvolume delete "$base/root"
+ btrfs subvolume create "$base/root"
+ chattr +C "$base/root"
+ fi
+ ''
+ + ''
image() { #
img=$1 size=$2 dir=$3
@@ -185,7 +291,16 @@ let
image "$base/root/root.img" ${r.disk.rootSize} ${r.run}/root
image "$base/home/home.img" ${r.disk.homeSize} ${r.run}/home
chmod 0755 ${r.run}/root
- '';
+ ''
+ + lib.optionalString (r.ephemeral || r.persist != [ ]) ''
+ install -d -m 0700 ${r.run}${persistDir}
+ ''
+ + lib.concatMapStrings
+ (p: ''
+ mkdir -p ${lib.escapeShellArg "${r.run}${persistDir}${p}"}
+ '')
+ r.persist
+ );
storageStop =
r:
@@ -197,37 +312,77 @@ let
# Installs the seed only when the root image has no system yet (first
# start, or after `robotnix reseed`). Never touches an installed robot.
+ # Ephemeral robots also save the fresh root as their clean copy.
seedScript =
r:
- pkgs.writeShellScript "${r.unit}-seed" ''
- set -euo pipefail
- root=${r.run}/root
- if [ ! -e "$root/nix/var/nix/profiles/system" ]; then
- echo "robotnix: installing the seed system into ${r.name}"
- nixos-install --root "$root" --system ${seedSystem r} \
- --no-root-passwd --no-bootloader --no-channel-copy
- install -d -m 0755 "$root/etc/nixos"
- install -m 0644 ${flakeNix r} "$root/etc/nixos/flake.nix"
- install -m 0644 ${robotnixNix r} "$root/etc/nixos/robotnix.nix"
- install -m 0644 ${r.seed.configuration} "$root/etc/nixos/configuration.nix"
- ${lib.optionalString r.git.enable ''
- echo "robotnix: setting up the git repo for ${r.name}'s flake"
- git -C "$root/etc/nixos" init -q
- git -C "$root/etc/nixos" config user.name ${h.nixStr r.git.userName}
- git -C "$root/etc/nixos" config user.email ${h.nixStr r.git.userEmail}
- ${lib.optionalString (r.git.remoteUrl != null) ''
- git -C "$root/etc/nixos" remote add origin ${h.nixStr r.git.remoteUrl}
+ pkgs.writeShellScript "${r.unit}-seed" (
+ ''
+ set -euo pipefail
+ root=${r.run}/root
+ if [ ! -e "$root/nix/var/nix/profiles/system" ]; then
+ echo "robotnix: installing the seed system into ${r.name}"
+ nixos-install --root "$root" --system ${seedSystem r} \
+ --no-root-passwd --no-bootloader --no-channel-copy
+ install -d -m 0755 "$root/etc/nixos"
+ install -m 0644 ${flakeNix r} "$root/etc/nixos/flake.nix"
+ install -m 0644 ${robotnixNix r} "$root/etc/nixos/robotnix.nix"
+ install -m 0644 ${r.seed.configuration} "$root/etc/nixos/configuration.nix"
+ ${lib.optionalString r.git.enable ''
+ echo "robotnix: setting up the git repo for ${r.name}'s flake"
+ git -C "$root/etc/nixos" init -q
+ git -C "$root/etc/nixos" config user.name ${h.nixStr r.git.userName}
+ git -C "$root/etc/nixos" config user.email ${h.nixStr r.git.userEmail}
+ ${lib.optionalString (r.git.remoteUrl != null) ''
+ git -C "$root/etc/nixos" remote add origin ${h.nixStr r.git.remoteUrl}
+ ''}
+ git -C "$root/etc/nixos" add -A
+ git -C "$root/etc/nixos" commit -q -m "robotnix initial seed" || true
''}
- git -C "$root/etc/nixos" add -A
- git -C "$root/etc/nixos" commit -q -m "robotnix initial seed" || true
- ''}
+ fi
+ # What nspawn and NixOS's init expect (same as nixos-containers).
+ mkdir -p "$root/etc" "$root/var/lib" "$root/root" "$root/home"
+ mkdir -p -m 0755 "$root/usr/bin"
+ chmod 0700 "$root/root"
+ [ -e "$root/etc/os-release" ] || [ -L "$root/etc/os-release" ] || touch "$root/etc/os-release"
+ [ -e "$root/etc/machine-id" ] || touch "$root/etc/machine-id"
+ ''
+ + lib.optionalString r.ephemeral ''
+ # Ephemeral: save the clean root once, before the robot ever boots.
+ if [ ! -e ${r.base}/pristine.id ]; then
+ echo "robotnix: saving ${r.name}'s clean root"
+ if [ -d ${r.base}/pristine ]; then btrfs subvolume delete ${r.base}/pristine; fi
+ sync -f "$root"
+ fsfreeze -f "$root"
+ rc=0
+ btrfs subvolume snapshot -r ${r.base}/root ${r.base}/pristine || rc=$?
+ fsfreeze -u "$root"
+ [ "$rc" -eq 0 ]
+ echo ${seedId r} > ${r.base}/pristine.id
+ fi
+ ''
+ );
+
+ # Ephemeral: swap root for a fresh copy of the clean root. Runs (as its
+ # own unit) before every start, including reboots from inside the robot.
+ resetRoot =
+ r:
+ pkgs.writeShellScript "${r.unit}-reset" ''
+ set -euo pipefail
+ base=${r.base}
+ root=${r.run}/root
+ if [ "$(cat "$base/pristine.id" 2>/dev/null)" != ${seedId r} ] || [ ! -d "$base/pristine" ]; then
+ echo "robotnix: no clean root for ${r.name}; restart its storage to reinstall" >&2
+ exit 1
fi
- # What nspawn and NixOS's init expect (same as nixos-containers).
- mkdir -p "$root/etc" "$root/var/lib" "$root/root" "$root/home"
- mkdir -p -m 0755 "$root/usr/bin"
- chmod 0700 "$root/root"
- [ -e "$root/etc/os-release" ] || [ -L "$root/etc/os-release" ] || touch "$root/etc/os-release"
- [ -e "$root/etc/machine-id" ] || touch "$root/etc/machine-id"
+ if mountpoint -q "$root"; then umount "$root"; fi
+ # Wait for the loop device to let go of the old image.
+ for _ in $(seq 1 20); do
+ [ -z "$(losetup -j "$base/root/root.img")" ] && break
+ sleep 0.5
+ done
+ btrfs subvolume delete "$base/root"
+ btrfs subvolume snapshot "$base/pristine" "$base/root"
+ mount -o loop,noatime "$base/root/root.img" "$root"
'';
preStart =
@@ -250,6 +405,8 @@ let
ip neigh del proxy ${r.address} dev ${ext} 2>/dev/null || true
'';
+ idmap = r: lib.optionalString r.privateUsers ":idmap";
+
nspawnArgs =
r:
lib.escapeShellArgs (
@@ -263,12 +420,18 @@ let
"--link-journal=try-guest"
"--resolv-conf=off"
"--timezone=off"
- "--bind=${r.run}/home:/home${lib.optionalString r.privateUsers ":idmap"}"
+ "--bind=${r.run}/home:/home${idmap r}"
]
+ # Kept folders of an ephemeral robot, stored inside the home image.
+ ++ map (p: "--bind=${r.run}${persistDir}${p}:${p}${idmap r}") r.persist
++ lib.optionals r.privateUsers [
"--private-users=pick"
"--private-users-ownership=auto"
]
+ # Docker needs the kernel keyring and bpf, which nspawn blocks by default.
+ ++ lib.optional r.allowDocker "--system-call-filter=add_key keyctl bpf"
+ ++ lib.optional r.allowTun "--bind=/dev/net/tun"
+ ++ map (c: "--load-credential=${c.id}:${c.file}") (hermesCreds r)
++ [ "/nix/var/nix/profiles/system/init" ]
);
@@ -300,6 +463,7 @@ let
pkgs.coreutils
pkgs.util-linux
pkgs.git
+ pkgs.btrfs-progs
];
environment.HOME = "/root";
serviceConfig = {
@@ -310,6 +474,31 @@ let
};
};
+ # Ephemeral: fresh root before every robot start. Its own unit because
+ # the robot unit blocks devices, and mounting the image needs loop
+ # devices. No RemainAfterExit, so each robot start runs it again.
+ "${r.unit}-reset" = lib.mkIf r.ephemeral {
+ description = "robotnix fresh root for ${r.name}";
+ requires = [
+ "${r.unit}-storage.service"
+ "${r.unit}-seed.service"
+ ];
+ bindsTo = [ "${r.unit}-storage.service" ];
+ after = [
+ "${r.unit}-storage.service"
+ "${r.unit}-seed.service"
+ ];
+ path = with pkgs; [
+ btrfs-progs
+ coreutils
+ util-linux
+ ];
+ serviceConfig = {
+ Type = "oneshot";
+ ExecStart = resetRoot r;
+ };
+ };
+
${r.unit} =
let
mem = h.toBytes r.memory.max;
@@ -317,7 +506,8 @@ let
"${r.unit}-storage.service"
"${r.unit}-seed.service"
"${r.unit}-dns.service"
- ];
+ ]
+ ++ lib.optional r.ephemeral "${r.unit}-reset.service";
in
{
description = "robotnix robot ${r.name}";
@@ -352,6 +542,7 @@ let
KillMode = "mixed";
KillSignal = "TERM";
DevicePolicy = "closed";
+ DeviceAllow = lib.mkIf r.allowTun [ "/dev/net/tun rwm" ];
# Resources.
CPUQuota = "${toString (r.cpus.max * 100)}%";
@@ -381,6 +572,7 @@ let
user
nft
access
+ ephemeral
;
snapshots = { inherit (r.snapshots) enable interval keep; };
})
diff --git a/secrets.nix b/secrets.nix
index 6a73781..3532eda 100644
--- a/secrets.nix
+++ b/secrets.nix
@@ -25,9 +25,13 @@ in
# Hermes envs
"secrets/hermes-env.age".publicKeys = [ ari fwdesk ];
-
"secrets/iu-project.age".publicKeys = [ ari minipc1 ];
+ # Robots
+ "secrets/robots-shared.age".publicKeys = [ ari fwdesk ];
+ "secrets/robots-genix.age".publicKeys = [ ari fwdesk ];
+ "secrets/robots-sibli.age".publicKeys = [ ari fwdesk ];
+
# Buzz stack env (minipc1)
"secrets/buzz-env.age".publicKeys = [ ari minipc1 ];
diff --git a/secrets/hermes-env.age b/secrets/hermes-env.age
index 447bdc0..3697952 100644
Binary files a/secrets/hermes-env.age and b/secrets/hermes-env.age differ
diff --git a/secrets/robots-genix.age b/secrets/robots-genix.age
new file mode 100644
index 0000000..423eabd
Binary files /dev/null and b/secrets/robots-genix.age differ
diff --git a/secrets/robots-shared.age b/secrets/robots-shared.age
new file mode 100644
index 0000000..f04e556
Binary files /dev/null and b/secrets/robots-shared.age differ
diff --git a/secrets/robots-sibli.age b/secrets/robots-sibli.age
new file mode 100644
index 0000000..44b5ecf
Binary files /dev/null and b/secrets/robots-sibli.age differ