@ours.network/fleet 0.9.5 → 0.9.7

package/dist/supervisor/types.d.ts

@@ -1,14 +1,47 @@
+/**
+ * Typed liveness verdict. `stopped` is a *definite* stop — the only state that
+ * lets a caller discard session context. `unknown` means the probe itself did
+ * not answer (bus unreachable, missing binary, unrecognised state) and must be
+ * treated as "may still be running".
+ */
+export type LivenessState = 'running' | 'stopped' | 'unknown';
+export interface Liveness {
+    state: LivenessState;
+    /** The backend's own words: native state tokens, or the probe failure. */
+    detail: string;
+}
+/** Whether `install` had to create the registration, or found it already there. */
+export interface InstallOutcome {
+    created: boolean;
+    detail: string;
+}
+export interface UninstallOutcome {
+    removed: boolean;
+    detail: string;
+}
 export interface SupervisorBackend {
     id: 'systemd' | 'launchd' | 'none';
     /** One-time host setup (unit template / dirs / linger). Returns human-readable messages. */
     init(binPath: string): Promise<string[]>;
-    /** Ensure the role's unit exists and is enabled + started. */
-    install(name: string, binPath: string): Promise<void>;
+    /**
+     * Ensure the role's unit exists and is enabled + started. Idempotent, and
+     * EXPLICIT about whether it created the registration: rollback may only
+     * remove what this transaction made, so "did I create this?" has to be
+     * answerable rather than assumed (6.2).
+     */
+    install(name: string, binPath: string): Promise<InstallOutcome>;
     start(name: string): Promise<void>;
     stop(name: string): Promise<void>;
     restart(name: string): Promise<void>;
     status(name: string): Promise<string>;
-    uninstall(name: string): Promise<void>;
+    /**
+     * Classify the role's liveness from the backend's own native result — never
+     * by matching prose in `status()`. Implementations must not throw: a failed
+     * probe is `unknown` with the failure in `detail`.
+     */
+    liveness(name: string): Promise<Liveness>;
+    /** Remove the registration. Idempotent; reports whether anything was there. */
+    uninstall(name: string): Promise<UninstallOutcome>;
     /** Command the CLI execs (stdio inherited) to show logs. */
     logsArgs(name: string, follow: boolean): {
         cmd: string;

package/dist/tmux.d.ts

@@ -1,14 +1,46 @@
 import { type Exec } from './exec.js';
+/** Socket-name prefix for every tmux server this fleet starts. */
+export declare const TMUX_SOCKET_PREFIX = "ours-fleet-";
+/**
+ * The tmux socket a session lives on — ONE SERVER PER SESSION (#32).
+ *
+ * Without `-L`, every role's pane lands on the single default tmux server. That
+ * server is a child of whichever role happened to start it first, so it sits in
+ * that role's unit cgroup: stopping that one unit takes down every other role's
+ * pane with it. A per-session socket puts each role's server in its own unit,
+ * which is what makes `stop` local to the role being stopped.
+ *
+ * Role names are `[A-Za-z0-9_-]+` (config.ts), so this is always a usable
+ * socket filename.
+ */
+export declare const tmuxSocket: (session: string) => string;
+/**
+ * Address a tmux command at that session's own server. EVERY tmux invocation in
+ * this repository must go through here — one that forgets `-L` silently talks to
+ * the shared default server and re-creates #32.
+ */
+export declare const tmuxArgs: (session: string, args: string[]) => string[];
 /** Thin tmux wrapper; all session handling in the core goes through this. */
 export declare class Tmux {
     private exec;
     constructor(exec?: Exec);
     has(name: string): Promise<boolean>;
     newSession(name: string, cwd: string, shellCommand: string): Promise<void>;
-    kill(name: string): Promise<void>;
+    /**
+     * Best-effort kill. Returns whether a session was actually there to destroy —
+     * the caller needs that to tell "we tore this session down" apart from "the
+     * program inside it exited on its own".
+     */
+    kill(name: string): Promise<boolean>;
     capture(name: string, lines?: number): Promise<string>;
     panePid(name: string): Promise<number | null>;
-    list(): Promise<string>;
+    /**
+     * List the live sessions among `names`, asking each server in turn.
+     * There is no fleet-wide `tmux ls` any more: a session per server means the
+     * caller says which sessions to ask about. A server that is not running
+     * answers non-zero and contributes nothing.
+     */
+    list(names: readonly string[]): Promise<string>;
     sendText(name: string, text: string): Promise<void>;
     sendKey(name: string, key: string): Promise<void>;
 }

package/dist/tmux.js

@@ -1,4 +1,25 @@
 import { realExec } from './exec.js';
+/** Socket-name prefix for every tmux server this fleet starts. */
+export const TMUX_SOCKET_PREFIX = 'ours-fleet-';
+/**
+ * The tmux socket a session lives on — ONE SERVER PER SESSION (#32).
+ *
+ * Without `-L`, every role's pane lands on the single default tmux server. That
+ * server is a child of whichever role happened to start it first, so it sits in
+ * that role's unit cgroup: stopping that one unit takes down every other role's
+ * pane with it. A per-session socket puts each role's server in its own unit,
+ * which is what makes `stop` local to the role being stopped.
+ *
+ * Role names are `[A-Za-z0-9_-]+` (config.ts), so this is always a usable
+ * socket filename.
+ */
+export const tmuxSocket = (session) => `${TMUX_SOCKET_PREFIX}${session}`;
+/**
+ * Address a tmux command at that session's own server. EVERY tmux invocation in
+ * this repository must go through here — one that forgets `-L` silently talks to
+ * the shared default server and re-creates #32.
+ */
+export const tmuxArgs = (session, args) => ['-L', tmuxSocket(session), ...args];
 /** Thin tmux wrapper; all session handling in the core goes through this. */
 export class Tmux {
     exec;
@@ -6,44 +27,60 @@ export class Tmux {
         this.exec = exec;
     }
     async has(name) {
-        return (await this.exec('tmux', ['has-session', '-t', name])).code === 0;
+        return (await this.exec('tmux', tmuxArgs(name, ['has-session', '-t', name]))).code === 0;
     }
     async newSession(name, cwd, shellCommand) {
-        const r = await this.exec('tmux', ['new-session', '-d', '-s', name, '-c', cwd, shellCommand]);
+        const r = await this.exec('tmux', tmuxArgs(name, ['new-session', '-d', '-s', name, '-c', cwd, shellCommand]));
         if (r.code !== 0)
             throw new Error(`tmux new-session '${name}' failed (${r.code}): ${r.stderr.trim()}`);
     }
+    /**
+     * Best-effort kill. Returns whether a session was actually there to destroy —
+     * the caller needs that to tell "we tore this session down" apart from "the
+     * program inside it exited on its own".
+     */
     async kill(name) {
-        await this.exec('tmux', ['kill-session', '-t', name]); // best-effort
+        return (await this.exec('tmux', tmuxArgs(name, ['kill-session', '-t', name]))).code === 0;
     }
     async capture(name, lines = 40) {
-        const r = await this.exec('tmux', ['capture-pane', '-t', name, '-p']);
+        const r = await this.exec('tmux', tmuxArgs(name, ['capture-pane', '-t', name, '-p']));
         if (r.code !== 0)
             throw new Error(`tmux capture-pane '${name}' failed: ${r.stderr.trim()}`);
         const all = r.stdout.replace(/\n+$/, '').split('\n');
         return all.slice(-lines).join('\n');
     }
     async panePid(name) {
-        const r = await this.exec('tmux', ['list-panes', '-t', name, '-F', '#{pane_pid}']);
+        const r = await this.exec('tmux', tmuxArgs(name, ['list-panes', '-t', name, '-F', '#{pane_pid}']));
         if (r.code !== 0)
             return null;
         const pid = parseInt(r.stdout.trim().split('\n')[0], 10);
         return Number.isFinite(pid) ? pid : null;
     }
-    async list() {
-        const r = await this.exec('tmux', ['ls']);
-        return r.code === 0 ? r.stdout.trimEnd() : '';
+    /**
+     * List the live sessions among `names`, asking each server in turn.
+     * There is no fleet-wide `tmux ls` any more: a session per server means the
+     * caller says which sessions to ask about. A server that is not running
+     * answers non-zero and contributes nothing.
+     */
+    async list(names) {
+        const lines = [];
+        for (const name of names) {
+            const r = await this.exec('tmux', tmuxArgs(name, ['ls']));
+            if (r.code === 0 && r.stdout.trim())
+                lines.push(r.stdout.trimEnd());
+        }
+        return lines.join('\n');
     }
     async sendText(name, text) {
-        let r = await this.exec('tmux', ['send-keys', '-t', name, '-l', text]);
+        let r = await this.exec('tmux', tmuxArgs(name, ['send-keys', '-t', name, '-l', text]));
         if (r.code !== 0)
             throw new Error(`tmux send-keys '${name}' failed: ${r.stderr.trim()}`);
-        r = await this.exec('tmux', ['send-keys', '-t', name, 'Enter']);
+        r = await this.exec('tmux', tmuxArgs(name, ['send-keys', '-t', name, 'Enter']));
         if (r.code !== 0)
             throw new Error(`tmux send-keys Enter '${name}' failed: ${r.stderr.trim()}`);
     }
     async sendKey(name, key) {
-        const r = await this.exec('tmux', ['send-keys', '-t', name, key]);
+        const r = await this.exec('tmux', tmuxArgs(name, ['send-keys', '-t', name, key]));
         if (r.code !== 0)
             throw new Error(`tmux send-keys '${name}' failed: ${r.stderr.trim()}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "0.9.5",
+  "version": "0.9.7",
   "description": "Harness-agnostic fleet of persistent, identity-bound AI agents. Declarative fleet.yaml, tmux or ACP sessions, supervision, and ours.network messaging.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",