agent-relay 12.2.7 → 12.3.0

package/dist/cli/lib/node-claim.d.ts

@@ -0,0 +1,460 @@
+/**
+ * Machine-local record of which live broker serves an enrolled node id.
+ *
+ * The Fleet enrollment store (`~/.agentworkforce/relay/fleet-enrollments.json`)
+ * is machine-global and NOT scoped to a broker state dir, so two `node up`
+ * invocations in different projects — or with different `--state-dir` values —
+ * happily adopt the same node id. The second registration takes over that
+ * node's Cloud delivery socket and the first broker stops receiving messages
+ * with no error on either side. This claim is the machine-local mutual
+ * exclusion the enrollment store does not provide.
+ *
+ * Ownership moves through two phases. A supervising CLI first *reserves* the
+ * node id (`status: 'reserved'`, `pid` = the CLI's own) BEFORE it spawns
+ * anything, because the broker queues `node.register` during its own
+ * initialization — any claim written after the spawn is written after the
+ * delivery socket could already have moved. Once a verified broker process
+ * exists the reservation is *adopted* (`status: 'active'`, `pid` = the broker's)
+ * in place, so ownership is never dropped in between.
+ *
+ * Neither phase depends on a process surviving long enough to record anything:
+ * the reservation also opens a hold descriptor that the broker child inherits
+ * across `fork` ({@link nodeClaimHoldPath}), so a supervisor killed anywhere
+ * between the spawn and the broker's first write still leaves a claim the
+ * kernel answers for.
+ */
+export interface NodeClaim {
+    version: 1;
+    node_id: string;
+    /**
+     * PID that owns the node id: the supervising CLI while the claim is
+     * `reserved`, the broker process holding the node-control socket once it is
+     * `active`.
+     */
+    pid: number;
+    /** Resolved broker state directory (`--state-dir`, or the project default). */
+    state_dir: string;
+    /** Broker HTTP API port, for pointing an operator at the live process. */
+    api_port?: number;
+    /** Registered broker/node name, when the start resolved one. */
+    broker_name?: string;
+    /**
+     * Absolute path of the executable this start resolved to run as its broker,
+     * and that file's `<device>:<inode>` at the moment it was recorded.
+     *
+     * This is what a later start compares a live process against when it has to
+     * decide whether that process is the broker holding the node id. The broker
+     * binary is operator-selectable (`AGENT_RELAY_BIN` / `BROKER_BINARY_PATH`)
+     * and a supported deployment may run it under any filename, so looking for
+     * `agent-relay` in a command line ruled exactly such a broker OUT — the
+     * "node id free" verdict that evicts a live broker's delivery socket. Both
+     * are best effort; see {@link classifyHolderProcess} for what their absence
+     * means.
+     */
+    broker_binary?: string;
+    broker_executable?: string;
+    /**
+     * PID of the child this start handed the hold descriptor to, recorded by the
+     * supervising CLI in the same turn `spawn()` returned it and long before any
+     * handshake completes.
+     *
+     * The executable identity above is recorded BEFORE the spawn, so it names the
+     * file the start was going to run — which is not always the file the running
+     * process maps. A shebang launcher runs as its interpreter (`lsof -d txt`
+     * reports `/bin/sh`), and a launcher that `exec`s the real broker maps that
+     * binary instead; neither matches what the claim recorded, and the holder
+     * read as an unrelated process. A pid survives both transitions, because
+     * `execve` keeps it. Only ever used as POSITIVE evidence, and only for a
+     * process already proven to hold this generation's descriptor — where a
+     * recycled number cannot reach, since nothing but a Relay start passes that
+     * descriptor on. See {@link classifyHolderProcess}.
+     */
+    broker_child_pid?: number;
+    /**
+     * `ps -o lstart` of `pid` at claim time. A PID alone cannot survive a reboot
+     * or wraparound: without this, an unrelated process that inherits the number
+     * would read as a live claim forever.
+     */
+    process_started_at?: string;
+    /**
+     * PID of the CLI supervising the broker, recorded from the reservation
+     * onward. After adoption the claim names both, and either one being alive
+     * keeps it held: a supervisor that dies after its broker registered must not
+     * leave that broker unprotected, and a broker that dies before its supervisor
+     * has finished shutting down must not open the node id up while the socket is
+     * still being torn down.
+     */
+    supervisor_pid?: number;
+    supervisor_started_at?: string;
+    /** `reserved` until a verified broker process owns the state dir. */
+    status?: 'reserved' | 'active';
+    claimed_at: string;
+    /**
+     * Sequence number encoded in this claim's filename. Ownership IS the
+     * successful exclusive creation of `<node>.<generation>.json`.
+     *
+     * A number is issued at most once for the life of the stem: releasing leaves
+     * a tombstone rather than removing the file, so `max(generation)` never
+     * decreases and no suspended start can wake up and re-create a number that
+     * has since been handed to somebody else. See {@link acquireNodeClaim} and
+     * {@link NodeClaimTombstone}.
+     */
+    generation?: number;
+    /**
+     * Unique per acquisition. A claim is only ever rewritten or removed by the
+     * acquisition that created it, and this is how that is proven.
+     */
+    owner_token?: string;
+}
+/** Whether a node id is free to serve, held by a live broker, or left behind. */
+export type NodeClaimState = 
+/** No claim file, or one that cannot be trusted to describe a live broker. */
+{
+    state: 'unclaimed';
+}
+/** A live local broker serves this node id; adopting it would evict its socket. */
+ | {
+    state: 'held';
+    claim: NodeClaim;
+    reason: string;
+}
+/** A claim file survives a broker that no longer runs; safe to take over. */
+ | {
+    state: 'stale';
+    claim: NodeClaim;
+    reason: string;
+};
+export interface NodeClaimDependencies {
+    /** Process environment, for the `AGENT_RELAY_HOME` override. */
+    env?: NodeJS.ProcessEnv;
+    /** Signal sender used for liveness probes. Defaults to `process.kill`. */
+    killProcess?: (pid: number, signal?: NodeJS.Signals | number) => void;
+    /**
+     * Shell runner used to read a pid's birth time and command line. Every CLI
+     * command passes its `CoreDependencies.execCommand`; without one the pid-reuse
+     * check is skipped and a live pid simply reads as held. This module imports no
+     * child_process itself so a claim check can be made from commands that mock
+     * that module.
+     */
+    execCommand?: (command: string) => Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+}
+export interface AcquireNodeClaimInput extends NodeClaimDependencies {
+    nodeId: string;
+    /** PID that will own the node id (the supervising CLI, for a reservation). */
+    pid: number;
+    stateDir: string;
+    apiPort?: number;
+    brokerName?: string;
+    /** Take the node over from a live broker instead of refusing. */
+    force?: boolean;
+    /** `reserved` (pre-spawn) or `active` (a verified broker owns the state dir). */
+    status?: 'reserved' | 'active';
+    /** Supervising CLI pid, when it differs from the owning `pid`. */
+    supervisorPid?: number;
+    /**
+     * Path of the executable this start will run as the broker, recorded so a
+     * later start can recognise that process by executable identity rather than
+     * by its filename. See {@link NodeClaim.broker_binary}.
+     */
+    brokerBinary?: string;
+}
+/** Thrown when a live local broker already serves the requested node id. */
+export declare class NodeClaimConflictError extends Error {
+    readonly nodeId: string;
+    readonly claim: NodeClaim;
+    constructor(nodeId: string, claim: NodeClaim);
+}
+/**
+ * Thrown when the kernel-level ownership fence could not be established.
+ *
+ * The hold descriptor is what makes a claim survive its own supervisor, so a
+ * start that cannot open one cannot honour the guarantee it is claiming under.
+ * It refuses instead of spawning an unfenced broker.
+ */
+export declare class NodeClaimHoldError extends Error {
+    readonly nodeId: string;
+    readonly holdPath: string;
+    constructor(nodeId: string, holdPath: string, cause?: unknown);
+}
+/**
+ * Thrown when ownership could not be established because other starts kept
+ * winning the exclusive create.
+ *
+ * Each attempt is a handful of syscalls, so exhausting them means a pathological
+ * amount of contention on one node id. Ownership cannot be established in that
+ * state, and starting anyway is exactly the double registration this module
+ * exists to prevent.
+ */
+export declare class NodeClaimContentionError extends Error {
+    readonly nodeId: string;
+    readonly claimsDir: string;
+    constructor(nodeId: string, claimsDir: string, cause?: unknown);
+}
+/**
+ * The enrolled node id a start will register as, or `undefined` when it will
+ * mint its own identity.
+ *
+ * `RELAY_NODE_ID` is sent verbatim in `node.register` (`resolve_broker_node_id`,
+ * crates/broker/src/runtime/init.rs), so an explicit node id IS the identity
+ * that can evict another broker, and it is claimed on that basis alone.
+ *
+ * This deliberately does not try to predict whether the broker will manage to
+ * authenticate as it. An earlier version claimed the id only when a token was
+ * in the environment or already in the broker's on-disk cache, and that was a
+ * hole: `init.rs` also wires a workspace-key token minter, and
+ * `node_control.rs` mints and connects with no cached token at all, so a start
+ * carrying nothing but `RELAY_NODE_ID` and workspace credentials walked past a
+ * live claim and took the node's delivery socket — the incident this module
+ * exists to close. Enumerating the credential routes instead of the identity
+ * just moves the hole to the next route that gets added.
+ *
+ * The cost is a start that could not have registered at all (no token, no
+ * workspace key, nothing to mint with) being refused when some other broker
+ * genuinely holds the id. That is recoverable in one flag (`--force`) and the
+ * start it refuses was headed for local-only operation anyway, while the
+ * opposite error is a silent delivery outage. `--local-only` starts register
+ * nothing and are excluded by the callers, not here.
+ */
+export declare function enrolledNodeIdForClaim(env: NodeJS.ProcessEnv): string | undefined;
+/** Directory holding the claim files for every node id served on this machine. */
+export declare function nodeClaimsDir(env?: NodeJS.ProcessEnv): string;
+/**
+ * Path of one generation of a node id's claim.
+ *
+ * Every write this module makes is the exclusive creation of a NEW generation,
+ * never an overwrite of an existing one — that is what makes takeover safe
+ * without a lock file (see {@link acquireNodeClaim}).
+ */
+export declare function nodeClaimPath(nodeId: string, env?: NodeJS.ProcessEnv, generation?: number): string;
+/**
+ * Sibling of a claim generation whose OPEN DESCRIPTORS are the ownership
+ * evidence, held by the kernel rather than written by a process.
+ *
+ * `<stem>.<generation>.hold` is created and opened by the supervising CLI
+ * BEFORE it spawns a broker, and the descriptor is inherited by the child
+ * across `fork`. From the instant a broker child exists — long before it binds
+ * its API, writes `connection.json` or queues `node.register` — some live
+ * process holds this file open, and the kernel drops the last reference the
+ * moment both of them die. That is what closes the window a supervisor
+ * SIGKILLed between the spawn and the broker's first write used to leave: there
+ * is no interval in which a competing start can see "dead supervisor, nothing
+ * published" and conclude the node id is free while the orphan is on its way to
+ * registering.
+ *
+ * Not matched by {@link CLAIM_FILENAME_PATTERN} (which requires `.json`), so it
+ * never counts as a generation of its own.
+ */
+export declare function nodeClaimHoldPath(nodeId: string, env?: NodeJS.ProcessEnv, generation?: number): string;
+/** Resolve a state dir to its canonical path so two spellings compare equal. */
+export declare function normalizeClaimStateDir(stateDir: string): string;
+/**
+ * The claim that currently owns `nodeId`, or `null`.
+ *
+ * A missing, unreadable, or malformed file reads as `null`: an unparseable
+ * claim is no evidence of a live broker, and treating it as one would brick
+ * every later `node up` for that node id.
+ */
+export declare function readNodeClaim(nodeId: string, env?: NodeJS.ProcessEnv): NodeClaim | null;
+/** The current claim for every node id on this machine, newest first. */
+export declare function listNodeClaims(env?: NodeJS.ProcessEnv): NodeClaim[];
+/**
+ * Whether anything other than `selfPids` still holds this claim's generation
+ * fenced, for a caller deciding whether ownership may be dropped.
+ *
+ * A release has to consult this, not just the pids on the record. The record
+ * names a broker only once a start got far enough to capture one: a spawn that
+ * rejects before it returns a client — a handshake that never completed, a
+ * SIGTERM the child outlived — leaves a broker child that no pid anywhere names,
+ * and releasing on "no live pid recorded" tombstones the claim and unlinks the
+ * hold file out from under a process that is still fenced by it. The next start
+ * then reads the node id as free while that child can still register. The
+ * descriptor is the one piece of evidence that exists from the instant the child
+ * does, so it is what decides.
+ *
+ * Holders are filtered exactly as {@link inspectNodeClaim} filters them, so a
+ * release never frees a node id that another start would still read as held.
+ */
+export declare function inspectNodeClaimHold(claim: NodeClaim, deps?: NodeClaimDependencies, selfPids?: ReadonlySet<number>): Promise<{
+    held: boolean;
+    reason: string;
+    pids: number[];
+}>;
+/**
+ * Create and open this generation's hold file, handing the supervising CLI the
+ * descriptor it passes to the broker child.
+ *
+ * Created exclusively (`wx`): only the acquisition that won the generation ever
+ * creates it, so a concurrent start can never replace the inode a live child is
+ * holding. Opened BEFORE the spawn, because a fence established after `fork`
+ * would leave exactly the gap it exists to close.
+ *
+ * Failing to establish the hold is FATAL to the start, which is why this throws
+ * rather than reporting a missing fence. Without the descriptor, a supervisor
+ * killed between the fork and the broker's `connection.json` write leaves a
+ * claim with only dead pids and no evidence at all — so the next start reads
+ * the node id as free and evicts a broker that is about to register. Continuing
+ * would mean spawning a broker under a guarantee that is not actually in force,
+ * which is worse than not starting: the operator can see and fix a refusal.
+ *
+ * @throws NodeClaimHoldError when the hold could not be established. Any
+ * partially created file and descriptor are cleaned up first, so a retry (or a
+ * later start, on the next generation) is not blocked by this one's debris.
+ */
+export declare function openNodeClaimHold(claim: NodeClaim, env?: NodeJS.ProcessEnv): number;
+/** Drop this process's reference to a hold file. Other holders keep it alive. */
+export declare function closeNodeClaimHold(fd: number | undefined): void;
+/**
+ * A live broker serving `stateDir`, discovered from the connection file the
+ * broker writes itself.
+ *
+ * This is the ownership evidence that survives the supervising CLI. The Rust
+ * broker writes `<state dir>/connection.json` (with its own pid) as soon as its
+ * API listener binds — BEFORE `connect_relay` and before `node.register` is
+ * queued (crates/broker/src/runtime/init.rs) — so a broker that was orphaned by
+ * a SIGKILLed supervisor before the CLI could record its pid is still
+ * discoverable by every other start on the machine. Without it, such an orphan
+ * reads as "nobody home" and the next `node up` evicts its delivery socket.
+ */
+export declare function findLiveStateDirBroker(stateDir: string, deps?: NodeClaimDependencies, 
+/** What the claim for this state dir knows about its broker executable. */
+hint?: {
+    binary?: string;
+    object?: string;
+}): Promise<{
+    pid: number;
+    startedAt?: string;
+} | null>;
+/**
+ * Classify a claim for `nodeId` — the read-only view used by preflight guards
+ * and diagnostics.
+ *
+ * A claim is retired only when every process it names is provably gone (the pid
+ * no longer exists, or its birth time no longer matches the one recorded) AND
+ * no live broker occupies its state dir. Everything else — including a `ps` we
+ * cannot run — reads as held, because refusing is recoverable (`--force`,
+ * `node down`) while a wrong "free" verdict silently cuts delivery to a live
+ * broker.
+ */
+export declare function inspectNodeClaim(nodeId: string, deps?: NodeClaimDependencies): Promise<NodeClaimState>;
+/** Live claims on this machine, for locating a broker across state dirs. */
+export declare function listHeldNodeClaims(deps?: NodeClaimDependencies): Promise<NodeClaim[]>;
+/**
+ * Record ownership of `nodeId`, refusing if a live local broker already holds
+ * it.
+ *
+ * Ownership IS the exclusive creation of the next generation file. Generations
+ * only increase and each one is created exactly once — for the whole life of
+ * the stem, not just while a claim is live: {@link releaseNodeClaim} leaves a
+ * tombstone in place of the record it drops, so the highest number on disk
+ * never falls back. Taking a node id over therefore never involves deleting a
+ * file another process might have replaced in the meantime — the failure mode
+ * that makes "validate the holder, then remove its record, then write ours"
+ * unsafe no matter how the validation is fenced.
+ *
+ * Without that, a start suspended between the scan and the create could wake up
+ * after a complete release-and-reacquire cycle, re-create a number that had
+ * been reissued to a live successor, pass the higher-generation check because
+ * its own file was the highest again, and then prune that successor's claim
+ * from its own stale scan. Both would stay alive with one of them recorded —
+ * exactly the double registration this module exists to prevent.
+ *
+ * Two starts that both observe the same stale claim therefore cannot both win:
+ * one creates generation N+1, the other collides (`EEXIST`) and re-reads, now
+ * seeing the winner's live claim. A start that created its generation while a
+ * third one was creating a higher one loses the confirm step below, removes its
+ * own file and refuses. Exactly one — the highest generation NUMBER ever issued
+ * for the stem, live claim or spent tombstone — can own the node id, which is
+ * the invariant the post-create check below enforces.
+ *
+ * Callers reserve with `status: 'reserved'` and their own pid BEFORE spawning a
+ * broker, open the generation's hold descriptor with {@link openNodeClaimHold}
+ * so the child inherits it, and then hand ownership to the verified broker with
+ * {@link adoptNodeClaim}.
+ *
+ * @throws NodeClaimConflictError when a live local broker holds the node id and
+ * `force` was not requested.
+ * @throws NodeClaimContentionError when no generation could be won at all.
+ */
+export declare function acquireNodeClaim(input: AcquireNodeClaimInput): Promise<NodeClaim>;
+/**
+ * Record the pid of the child this reservation just handed its hold descriptor
+ * to, so a later start can recognise that process no matter what it becomes.
+ *
+ * Deliberately synchronous, and called from the spawn itself rather than from
+ * the adoption that follows it: the whole point is to have the pid on disk
+ * before the child can `exec` into something the recorded executable no longer
+ * describes, and before this supervisor can be killed. It is a plain write of
+ * OUR OWN generation with no `await` between the read and the write, so it
+ * cannot interleave with anything.
+ *
+ * A failure is never fatal. This is additional positive evidence layered on top
+ * of a fence that is already in place — the descriptor was inherited at the
+ * spawn — so losing it costs the launcher/exec case, not the guarantee. The
+ * caller keeps the returned claim, which is unchanged when nothing was written.
+ */
+export declare function recordSpawnedBrokerChild(reservation: NodeClaim, pid: number, env?: NodeJS.ProcessEnv): NodeClaim;
+/**
+ * Hand a reservation to the verified broker process that now owns the state
+ * dir.
+ *
+ * Only the acquisition that created a generation ever rewrites it, so this is a
+ * conflict-free in-place update — but it is still conditional on that
+ * generation still being the highest: a `--force` takeover that landed while
+ * this broker was starting has already won the node id, and continuing would
+ * put two brokers back on one delivery socket. Losing here fails startup, which
+ * tears this broker down.
+ *
+ * @throws NodeClaimConflictError when the reservation no longer owns the node id.
+ */
+export declare function adoptNodeClaim(input: {
+    reservation: NodeClaim;
+    /** PID of the verified broker process holding the node-control socket. */
+    pid: number;
+    apiPort?: number;
+    brokerName?: string;
+    env?: NodeJS.ProcessEnv;
+    killProcess?: NodeClaimDependencies['killProcess'];
+    execCommand?: NodeClaimDependencies['execCommand'];
+}): Promise<NodeClaim>;
+/**
+ * Drop a claim this start owns, leaving its generation number spent.
+ *
+ * The record is REPLACED by a tombstone rather than removed. Removing it made
+ * the number reusable, and a suspended start could then re-create a generation
+ * that had since been handed to somebody else: it would pass the
+ * higher-generation check (its own file was the highest again) and prune the
+ * successor's live claim from its own stale scan, leaving two brokers alive on
+ * one node id with only one of them recorded. A tombstone keeps
+ * `max(generation)` from ever decreasing, so no number is issued twice; it
+ * parses as no claim at all, so the node id reads free immediately; and the
+ * next acquisition prunes it, so at most one spent file per node id is ever on
+ * disk.
+ *
+ * Only the acquisition that created a generation ever rewrites it, proven by
+ * `owner_token`, and the read and the write are adjacent syscalls with no await
+ * in between.
+ */
+export declare function releaseNodeClaim(claim: NodeClaim, env?: NodeJS.ProcessEnv): Promise<boolean>;
+/**
+ * Release the claims a broker pid held in a state dir. `node down` stops a
+ * broker it did not start, so it cannot name the node id the claim was written
+ * for — the pid and state dir it verified are what it has.
+ *
+ * A claim for that state dir whose every recorded pid is already dead is
+ * released too: that is the orphan left by a supervisor that was killed before
+ * it could record its broker's pid, and `down` has just proven the state dir's
+ * broker is gone.
+ */
+export declare function releaseNodeClaimsForBroker(input: {
+    pid: number;
+    stateDir: string;
+    env?: NodeJS.ProcessEnv;
+    killProcess?: NodeClaimDependencies['killProcess'];
+    execCommand?: NodeClaimDependencies['execCommand'];
+}): Promise<NodeClaim[]>;
+/** One-line description of the broker holding a claim, for operator output. */
+export declare function describeNodeClaimHolder(claim: NodeClaim): string;
+//# sourceMappingURL=node-claim.d.ts.map

package/dist/cli/lib/node-claim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-claim.d.ts","sourceRoot":"","sources":["../../../src/cli/lib/node-claim.ts"],"names":[],"mappings":"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"}