Struct ShepPaths 

pub struct ShepPaths {
    pub home: PathBuf,
    pub daemon_config: PathBuf,
    pub snapshot: PathBuf,
    pub logs: PathBuf,
    pub pids: PathBuf,
    pub run: PathBuf,
    pub socket: PathBuf,
    pub barks: PathBuf,
    pub kv: 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

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.

Two different kinds of thing behind one field, on purpose. On unix it is a filesystem path, run/shep.sock, and a real AF_UNIX socket file lives there. On Windows it is Self::pipe_name — a named pipe’s \\.\pipe\... name, which is path-shaped but names an object in the kernel’s pipe namespace rather than a file on any volume.

One field rather than two because every consumer in the workspace treats this as an opaque address it hands to Client::connect, and a second field would make all of them choose. The one place the difference is load-bearing is a caller that treats this as a file — shep-cli’s wait_for_socket_to_disappear is the only one, and it carries its own Windows arm because a pipe has no directory entry to watch: it stops existing when its last handle closes, so “has the daemon gone” is a connect attempt there, not a Path::exists.

A corollary worth stating because it silently breaks otherwise: socket.parent() is $SHEP_HOME/run on unix and the meaningless \\.\pipe on Windows. Nothing may derive a directory from this field.

barks: PathBuf

Bark history ring: barks.jsonl

kv: PathBuf

Key/value store: kv.json

Implementations

impl ShepPaths

pub fn pipe_name(&self) -> String

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

The readable half is the home path with every non-alphanumeric character collapsed to -, capped, so an operator reading a pipe name can tell which home it belongs to. That half alone does not identify a home: \, :, ., _ and a literal - all become -, so C:\a\b and C:\a-b sanitize to one string. The pipe namespace is machine-global and crate::transport::Listener::bind asks for first_pipe_instance, so a collision does not surface as an error: the second home’s daemon is refused as already running, and that home’s CLI then drives the first home’s flock. No handshake field carries a home, so nothing downstream would catch it.

The appended digest of the full home path is what makes the name distinct, and it is why the name is not stable across this change: a daemon already bound under the old form is unreachable to a client built after it.

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, a \\.\pipe\... name on Windows — for the reason that field’s own doc gives. Everything else is identical on both.

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