Enum SessionCommand 

pub enum SessionCommand {
    New {
        name: Option<String>,
        relay: String,
        with_local: bool,
        local_relay: String,
        no_daemon: bool,
        local_only: bool,
        json: bool,
    },
    List {
        json: bool,
    },
    ListLocal {
        json: bool,
    },
    PairAllLocal {
        settle_secs: u64,
        federation_relay: String,
        json: bool,
    },
    MeshStatus {
        stale_secs: u64,
        json: bool,
    },
    Env {
        name: Option<String>,
        json: bool,
    },
    Current {
        json: bool,
    },
    Destroy {
        name: String,
        force: bool,
        json: bool,
    },
}

Variants

New

Bootstrap a new isolated session in this machine’s sessions root. With no name, derives one from basename(cwd) and caches it in the registry so re-running from the same project reuses it. Runs init + claim + spawns a session-local daemon, all inside the new session’s WIRE_HOME. Output includes the export WIRE_HOME=... line operators paste into their shell to activate it.

Fields

name: Option<String>

Optional session name. Default = derived from basename(cwd).

relay: String

Relay URL for the session’s slot allocation + handle claim.

with_local: bool

v0.5.17: also allocate a second slot on a same-machine local relay (defaults to http://127.0.0.1:8771). Within-machine sister-session traffic prefers this path: zero round-trip latency, zero metadata exposure to the public relay. Probes <local-relay>/healthz first; silently skips if the local relay isn’t running.

local_relay: String

v0.5.17: override the local relay URL probed by --with-local. Default is http://127.0.0.1:8771 to match wire relay-server --bind 127.0.0.1:8771 --local-only.

no_daemon: bool

Skip spawning the session-local daemon. Use when you want to drive sync explicitly from the agent or test rig.

local_only: bool

v0.6.6: create a federation-free session — no nick claim on --relay, no federation slot allocation. Implies --with-local. The session exists only to coordinate with other sister sessions on this machine; it has no public address and cannot be reached from outside. Reserved nicks (wire, slancha, etc.) are allowed because nothing tries to publish them.

json: bool

Emit JSON.

List

List all sessions on this machine with their handle, DID, daemon liveness, and the cwd they’re associated with.

Fields

json: bool

ListLocal

List sister sessions reachable via a same-machine local relay (v0.5.17 dual-slot). Groups sessions by the local-relay URL they share. Sessions without a Local-scope endpoint are listed separately so the operator can tell which are federation-only. Read-only — does not probe any relay or touch daemons.

Fields

json: bool

PairAllLocal

v0.6.0 (issue #12): mesh-pair every sister session against every other in O(N²) handshakes. For each unordered pair (A, B) that is not already paired, drives the bilateral flow end-to-end: wire add from A → B (queued + pushed), wire pair-accept on B’s side, then a final pull on A so the ack lands. Idempotent — re-running skips pairs already in state.peers.

Trust anchor: the operator running this command owns every session listed in wire session list-local (they all live under the same $WIRE_HOME/sessions/ directory the operator chose). That filesystem-permission boundary IS the consent for both sides — the bilateral SAS / network-level handshake assumes strangers; same-uid sister sessions are by definition not strangers. Cross-uid sister sessions are out of scope; today wire session list-local only enumerates this user’s sessions.

Fields

settle_secs: u64

Seconds to wait between handshake stages for pair_drop / pair_drop_ack to propagate over the relay. Default 1s (local-relay is typically <100ms RTT). Bump if you see “pending-inbound never arrived” errors on a slow relay.

federation_relay: String

Federation relay to bind each wire add against. Default https://wireup.net. Sister sessions should be bound to the same federation relay; the pair handshake routes through it for the .well-known resolution + pair_drop deposit.

json: bool

MeshStatus

v0.6.2 (issue #18): live view of the sister-session mesh on this machine. Enumerates every session in wire session list-local, walks each session’s relay.json#peers to find which other sister sessions it has pinned, and probes the local relay for each edge’s last_pull_at_unix to surface stale/silent peers. Text output is the pin matrix + per-edge health roll-up; JSON is {sessions, edges, local_relay, summary} so scripts can scrape.

Read-only — does NOT touch peers or daemons, only the relay’s public /v1/slot/<id>/state endpoint with the slot tokens we already hold. Silent on any probe failure (degrades to “no signal” rather than abort) so a half-broken mesh is still inspectable.

Fields

stale_secs: u64

Threshold in seconds for “stale” classification on an edge. An edge whose receiver hasn’t polled their slot in this long is flagged. Default 300s (5 min) — same as the per-send phyllis attentiveness nag.

json: bool

Env

Print the export WIRE_HOME=... line for a session, so a shell can eval $(wire session env <name>) to activate it. With no name, resolves the cwd through the registry.

Fields

name: Option<String>

Session name. Default = derived from cwd via the registry.

json: bool

Current

Identify which session the current cwd maps to in the registry. Prints (none) if cwd isn’t registered — wire session new would create one.

Fields

json: bool

Destroy

Tear down a session: kills its daemon (if running), deletes its state directory, and removes it from the registry. Requires --force because state loss is unrecoverable (keypair gone).

Fields

name: String

force: bool

Confirm state-deleting operation.

json: bool

Trait Implementations

impl Debug for SessionCommand

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

Formats the value using the given formatter.

impl FromArgMatches for SessionCommand

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for SessionCommand

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand