Struct ShepPaths 

pub struct ShepPaths {

    pub home: PathBuf,
    pub daemon_config: PathBuf,
    pub dogs_config: PathBuf,
    pub snapshot: PathBuf,
    pub logs: PathBuf,
    pub pids: PathBuf,
    pub run: PathBuf,
    pub socket: PathBuf,
    pub barks: PathBuf,
    pub kv: PathBuf,
    pub overrides: PathBuf,
    pub secrets: PathBuf,
    pub secrets_cache: PathBuf,
}

Resolved filesystem layout for one shep home

All paths are derived from $SHEP_HOME (default <home>/.shep); nothing here touches the filesystem. The root itself is created by the CLI’s own ensure_home, for the commands that need it before any daemon exists (startup above all), and everything under it by shep_daemon::boot::init_dirs on each boot.

Fields

home: PathBuf

Root: $SHEP_HOME

daemon_config: PathBuf

Daemon config: shep.toml

dogs_config: PathBuf

A dog’s own settings: dogs.toml

Separate from Self::daemon_config rather than a section inside it, so lookout can write a dog’s config without writing into the daemon’s own hand-authored file.

snapshot: PathBuf

Flock snapshot (muster roll): flock.json

logs: PathBuf

Log directory

pids: PathBuf

Pid-file directory

run: PathBuf

Runtime dir (sockets; created 0700)

socket: PathBuf

The control address the client dials and the daemon answers on.

Unix: a filesystem path, run/shep.sock, naming a real AF_UNIX socket file. Windows: Self::pipe_name, path-shaped but naming an object in the kernel’s pipe namespace, not a file on any volume. Never derive a directory from this field: socket.parent() is meaningless on Windows. A pipe has no directory entry to watch, so “has the daemon gone” needs a connect attempt there, not Path::exists.

barks: PathBuf

Bark history ring: barks.jsonl

kv: PathBuf

Key/value store: kv.json

overrides: PathBuf

Operator override store: overrides.json

secrets: PathBuf

Secret store: secrets.json

secrets_cache: PathBuf

Cached provider values: secrets-cache.json

Derived and safe to delete, unlike Self::secrets: a provider dog rewrites it on its next push.

Implementations

impl ShepPaths

pub fn pipe_name(&self) -> String

Windows named-pipe identity for this home: \\.\pipe\shep-<sanitized>-<digest>

The sanitized stem is not unique alone: \, :, ., _ and a literal - all collapse to -, so C:\a\b and C:\a-b sanitize to one string. The digest of the full home path is what keeps two homes distinct; without it a collision would not error, it would refuse the second daemon as already running and let its CLI drive the first home’s flock.

Changing this derivation breaks any already-running daemon: it stays bound under a name a client built afterward would never dial.

pub fn resolve(env: &dyn Fn(&str) -> Option<String>, home_dir: &Path) -> Self

Resolves the layout from an environment lookup and the user’s home dir

Self::socket resolves per-platform: a socket file under run/ on unix, Self::pipe_name on Windows. Everything else is identical.

Why String and not OsString

user_home takes an OsString lookup and this takes a String one, which reads like an oversight and is not. A home path does not stay a path: it reaches the {{SHEP_HOME}} template, Self::pipe_name and every log path on the wire as text, and each of those conversions is lossy. Widening this signature would move the loss rather than remove it, and it would break every caller of a published crate to do so.

The CLI refuses a home that is not valid UTF-8 instead, at the one door an operator can name one through, so nothing lossy reaches here. A library caller supplying its own lookup has already chosen its encoding by building a String.

Trait Implementations

impl Clone for ShepPaths

fn clone(&self) -> ShepPaths

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ShepPaths

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for ShepPaths

impl PartialEq for ShepPaths

fn eq(&self, other: &ShepPaths) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ShepPaths