@vibesdotdev/pm 0.0.0-stage → 1.0.0-rc.3

package/dist/utils/daemon-reachability.d.ts

@@ -0,0 +1,87 @@
+/**
+ * PM daemon reachability and socket probing.
+ *
+ * Separated from daemon.ts so clients (and lightweight callers like `vibes update`)
+ * can verify daemon socket connectivity without pulling the entire PMDaemon
+ * class, ProcessManager, ProcessStore, or localdb into client bundles.
+ */
+import { CapabilityError, type RuntimeRef } from '@vibesdotdev/kernel';
+import { type PMPathRuntime } from './vibes-home.ts';
+/** What the admitted-daemon probes read from the runtime they are handed. */
+export type PMDaemonProbeRuntime = RuntimeRef & PMPathRuntime;
+/**
+ * What a socket probe reads from the runtime it is handed: its socket service,
+ * and the lifecycle that bounds the connect (runtime-rpc's one connect wait).
+ */
+export type PMSocketProbeRuntime = RuntimeRef;
+/**
+ * `EINVAL` from a unix connect: the kernel cannot address this path — it is
+ * longer than a unix `sockaddr`'s `sun_path` and a component on the way does
+ * not exist yet (measured on macOS: the same too-long path answers ENOENT
+ * while its directory exists, EINVAL once a parent directory is missing).
+ * Nothing can ever answer there through this probe, so it is this probe's
+ * "no", not an internal failure — and a daemon that DID bind at such a path
+ * is still reached, because once its socket directory exists the connect
+ * resolves and succeeds. Refusing to classify it would make every read
+ * surface crash on a deep vibes home before the first daemon ever started.
+ */
+export declare function isUnaddressableSocketPath(error: CapabilityError): boolean;
+/**
+ * Check connectivity to the PM daemon's rpc-unix socket by opening and
+ * immediately closing a real socket connection.
+ */
+export declare function canConnectToPMSocket(runtime: PMSocketProbeRuntime, socketPath: string, timeoutMs: number): Promise<boolean>;
+/**
+ * Check if the daemon at `socketPath` is reachable. This is stricter than
+ * "running" (PID alive) and is what clients need. The admitted workspace's
+ * socket is `admittedPMSocketPath(runtime)`.
+ */
+export declare function isDaemonReachable(runtime: PMSocketProbeRuntime, timeoutMs: number, socketPath: string): Promise<boolean>;
+/**
+ * The admitted workspace's PM socket (framework-M8), under the roots of the
+ * runtime handed in. An unadmitted binding fails with `workspace-not-admitted`;
+ * it is never read as "no daemon".
+ */
+export declare function admittedPMSocketPath(runtime: PMDaemonProbeRuntime): Promise<string>;
+/**
+ * Whether the admitted workspace's daemon of `runtime` is running: its socket
+ * answers, or its PID file names a live process.
+ */
+export declare function isDaemonRunning(runtime: PMDaemonProbeRuntime): Promise<boolean>;
+/** What one probe learned, so every surface can say the same thing. */
+export interface DaemonProbe {
+    /** The socket answered, or the PID file names a live process. */
+    running: boolean;
+    /** The rpc socket accepted a connection inside `socketTimeoutMs`. */
+    reachable: boolean;
+    /** The live pid from the PID file; null when the file is absent or stale. */
+    pid: number | null;
+    socketTimeoutMs: number;
+}
+export interface DaemonProbeDeps {
+    /**
+     * Did the daemon's socket accept a connection within `timeoutMs`? A caller
+     * that already holds a client (workspace-aware socket path) passes its own.
+     */
+    socketAnswers?: (timeoutMs: number) => Promise<boolean>;
+    /** The live pid named by the PID file, or null. */
+    readPid?: () => Promise<number | null>;
+}
+/**
+ * One probe for `pm status`, `pm daemon status` and anything else that must
+ * decide whether the daemon is there. Socket first, PID file always: a socket
+ * race lost under load (measured 2026-09-05: `pm status` printed "PM daemon
+ * is not running" while `pm daemon status` showed pid 32243 and `pm list`
+ * listed 10 processes) is reported as running-but-unreachable, never as absent.
+ * A socket or PID path that cannot be resolved (no runtime roots, an
+ * unadmitted workspace) is the resolver's typed failure, never "absent".
+ */
+export declare function probeDaemon(options: {
+    /** The runtime whose admitted workspace names the socket and PID file. */
+    runtime: PMDaemonProbeRuntime;
+    socketTimeoutMs?: number;
+    socketPath?: string;
+    pidFile?: string;
+    deps?: DaemonProbeDeps;
+}): Promise<DaemonProbe>;
+//# sourceMappingURL=daemon-reachability.d.ts.map

package/dist/utils/daemon-reachability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-reachability.d.ts","sourceRoot":"","sources":["../../src/utils/daemon-reachability.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,eAAe,EAAqB,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAG1F,OAAO,EAAwB,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAM3E,6EAA6E;AAC7E,MAAM,MAAM,oBAAoB,GAAG,UAAU,GAAG,aAAa,CAAC;AAE9D;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG,UAAU,CAAC;AAa9C;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAEzE;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,oBAAoB,EAC7B,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,GACf,OAAO,CAAC,OAAO,CAAC,CAgBlB;AAoBD;;;;GAIG;AACH,wBAAsB,iBAAiB,CACtC,OAAO,EAAE,oBAAoB,EAC7B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GAChB,OAAO,CAAC,OAAO,CAAC,CAElB;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,MAAM,CAAC,CAGzF;AAED;;;GAGG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,OAAO,CAAC,CAGrF;AAED,uEAAuE;AACvE,MAAM,WAAW,WAAW;IAC3B,iEAAiE;IACjE,OAAO,EAAE,OAAO,CAAC;IACjB,qEAAqE;IACrE,SAAS,EAAE,OAAO,CAAC;IACnB,6EAA6E;IAC7E,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC/B;;;OAGG;IACH,aAAa,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACxD,mDAAmD;IACnD,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CACvC;AAWD;;;;;;;;GAQG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE;IAC1C,0EAA0E;IAC1E,OAAO,EAAE,oBAAoB,CAAC;IAC9B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,eAAe,CAAC;CACvB,GAAG,OAAO,CAAC,WAAW,CAAC,CAavB"}

package/dist/utils/daemon-reachability.js

@@ -0,0 +1,131 @@
+/**
+ * PM daemon reachability and socket probing.
+ *
+ * Separated from daemon.ts so clients (and lightweight callers like `vibes update`)
+ * can verify daemon socket connectivity without pulling the entire PMDaemon
+ * class, ProcessManager, ProcessStore, or localdb into client bundles.
+ */
+import { CapabilityError, isCapabilityError } from '@vibesdotdev/kernel';
+import { requireAdmittedWorkspace } from "../admission.js";
+import { getPMSocketPath } from "./socket-paths.js";
+import { resolvePMPathOptions } from "./vibes-home.js";
+import { getAdmittedDaemonPidPath, readDaemonPid } from "./daemon-pid.js";
+import { readSocketInode } from "./socket-inode.impl.consumer.js";
+import { attempt } from "./attempt.js";
+import { rethrowFailure } from "../helpers/failure.js";
+/**
+ * The connect outcomes that answer this probe's question — did a daemon
+ * answer at the socket within `timeoutMs`? — with "no": nothing is listening
+ * (`socket-unreachable`), or nothing answered in time (`socket-connect-timeout`,
+ * `rpc-handshake-timeout`; `pm status` reports that as running-but-unreachable
+ * when the PID file names a live daemon), or the kernel cannot address the
+ * path at all (`EINVAL`; see {@link isUnaddressableSocketPath}). A permission
+ * refusal, a peer that is not a PM daemon, or any other failure propagates.
+ */
+const NOT_ANSWERING_REASONS = new Set(['socket-unreachable', 'socket-connect-timeout', 'rpc-handshake-timeout']);
+/**
+ * `EINVAL` from a unix connect: the kernel cannot address this path — it is
+ * longer than a unix `sockaddr`'s `sun_path` and a component on the way does
+ * not exist yet (measured on macOS: the same too-long path answers ENOENT
+ * while its directory exists, EINVAL once a parent directory is missing).
+ * Nothing can ever answer there through this probe, so it is this probe's
+ * "no", not an internal failure — and a daemon that DID bind at such a path
+ * is still reached, because once its socket directory exists the connect
+ * resolves and succeeds. Refusing to classify it would make every read
+ * surface crash on a deep vibes home before the first daemon ever started.
+ */
+export function isUnaddressableSocketPath(error) {
+    return error.reason === 'socket-connect-failed' && error.details?.errno === 'EINVAL';
+}
+/**
+ * Check connectivity to the PM daemon's rpc-unix socket by opening and
+ * immediately closing a real socket connection.
+ */
+export async function canConnectToPMSocket(runtime, socketPath, timeoutMs) {
+    const { connectUnix } = await import('@vibesdotdev/kernel-rpc/unix');
+    const connecting = await attempt(() => connectUnix(socketPath, { runtime, timeoutMs }));
+    if (!connecting.ok) {
+        const failure = connecting.failure;
+        // Absent, or not answering in time, is this probe's "no" (timeouts
+        // included on purpose: probeDaemon reports them as running-but-unreachable).
+        if (failure instanceof Error && isCapabilityError(failure) && failure.reason && NOT_ANSWERING_REASONS.has(failure.reason)) {
+            if (failure.reason === 'socket-unreachable')
+                await refuseNonSocketInode(runtime, socketPath, failure);
+            return false;
+        }
+        if (failure instanceof Error && isCapabilityError(failure) && isUnaddressableSocketPath(failure))
+            return false;
+        return rethrowFailure(failure);
+    }
+    await connecting.value.close();
+    return true;
+}
+/**
+ * A connect that found "nothing listening" may have hit a file that is not a
+ * socket: Linux answers a connect to a regular file with `ECONNREFUSED` (macOS
+ * with `ENOTSOCK`, already typed by the transport). A non-socket inode at the
+ * daemon's socket path is a misconfiguration on every platform, never
+ * absence, so it fails the probe typed. A missing path is absence.
+ */
+async function refuseNonSocketInode(runtime, socketPath, cause) {
+    const inode = await readSocketInode(runtime, socketPath);
+    if (!inode.present || inode.socket)
+        return;
+    throw new CapabilityError(`${socketPath} is not a socket; the PM daemon socket path is occupied.`, 'INTERNAL', {
+        reason: 'socket-connect-failed',
+        details: { socketPath, errno: 'ENOTSOCK' },
+        recoveryHint: 'Remove or move the file at the daemon socket path, then restart the PM daemon.',
+        cause
+    });
+}
+/**
+ * Check if the daemon at `socketPath` is reachable. This is stricter than
+ * "running" (PID alive) and is what clients need. The admitted workspace's
+ * socket is `admittedPMSocketPath(runtime)`.
+ */
+export async function isDaemonReachable(runtime, timeoutMs, socketPath) {
+    return await canConnectToPMSocket(runtime, socketPath, timeoutMs);
+}
+/**
+ * The admitted workspace's PM socket (framework-M8), under the roots of the
+ * runtime handed in. An unadmitted binding fails with `workspace-not-admitted`;
+ * it is never read as "no daemon".
+ */
+export async function admittedPMSocketPath(runtime) {
+    const admitted = await requireAdmittedWorkspace(runtime);
+    return getPMSocketPath(admitted.root, await resolvePMPathOptions(runtime));
+}
+/**
+ * Whether the admitted workspace's daemon of `runtime` is running: its socket
+ * answers, or its PID file names a live process.
+ */
+export async function isDaemonRunning(runtime) {
+    if (await canConnectToPMSocket(runtime, await admittedPMSocketPath(runtime), 250))
+        return true;
+    return (await readDaemonPid(runtime, await getAdmittedDaemonPidPath(runtime))) !== null;
+}
+async function socketAnswersAt(runtime, socketPath, timeoutMs) {
+    const path = socketPath ?? (await admittedPMSocketPath(runtime));
+    return canConnectToPMSocket(runtime, path, timeoutMs);
+}
+/**
+ * One probe for `pm status`, `pm daemon status` and anything else that must
+ * decide whether the daemon is there. Socket first, PID file always: a socket
+ * race lost under load (measured 2026-09-05: `pm status` printed "PM daemon
+ * is not running" while `pm daemon status` showed pid 32243 and `pm list`
+ * listed 10 processes) is reported as running-but-unreachable, never as absent.
+ * A socket or PID path that cannot be resolved (no runtime roots, an
+ * unadmitted workspace) is the resolver's typed failure, never "absent".
+ */
+export async function probeDaemon(options) {
+    const { runtime } = options;
+    const socketTimeoutMs = options.socketTimeoutMs ?? 250;
+    const socketAnswers = options.deps?.socketAnswers ??
+        ((timeoutMs) => socketAnswersAt(runtime, options.socketPath, timeoutMs));
+    const readPid = options.deps?.readPid ??
+        (async () => readDaemonPid(runtime, options.pidFile ?? (await getAdmittedDaemonPidPath(runtime))));
+    const reachable = await socketAnswers(socketTimeoutMs);
+    const pid = await readPid();
+    return { running: reachable || pid !== null, reachable, pid, socketTimeoutMs };
+}
+//# sourceMappingURL=daemon-reachability.js.map

package/dist/utils/daemon-reachability.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-reachability.js","sourceRoot":"","sources":["../../src/utils/daemon-reachability.ts"],"names":[],"mappings":"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"}

package/dist/utils/daemon-stdio-timestamps.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ISO timestamps for the daemon's raw stdout/stderr.
+ *
+ * `pm daemon start` routes the detached daemon's fds 1/2 into
+ * `pm-daemon.stdout.log` / `pm-daemon.stderr.log`. Everything that lands
+ * there — the console sink of `@vibesdotdev/logging`, bare `console.log`
+ * calls, forwarded raw lines — arrives without a clock, so the file cannot
+ * answer "when did the health monitor kill mcp-server-dev" (measured
+ * 2026-09-06: 4.4MB of stderr, not one line carries a time; the structured
+ * `pm-daemon.log` that does was last written 2026-08-11).
+ *
+ * Stamping happens at the process's own write seam — the one place every
+ * sink and every stray print pass through — so no logger has to be taught.
+ */
+import type { RuntimeStdioCapture, RuntimeStdioCaptureLease, RuntimeStdioCaptureOptions } from '@vibesdotdev/kernel';
+/**
+ * Returns a function that prefixes every line START in the chunks it sees
+ * with `<iso> `. A partial line (no trailing newline) keeps its continuation
+ * unstamped in the next chunk, so a line written in two pieces gets one stamp.
+ */
+export declare function createLineTimestamper(now?: () => string): (chunk: string | Uint8Array) => string;
+/** Acquire one handed host lease with independent timestamp state per channel. */
+export declare function installStdioTimestamps(capture: RuntimeStdioCapture, now?: () => string, consume?: RuntimeStdioCaptureOptions['onWrite']): Promise<RuntimeStdioCaptureLease>;
+//# sourceMappingURL=daemon-stdio-timestamps.d.ts.map

package/dist/utils/daemon-stdio-timestamps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-stdio-timestamps.d.ts","sourceRoot":"","sources":["../../src/utils/daemon-stdio-timestamps.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AAErH;;;;GAIG;AACH,wBAAgB,qBAAqB,CACpC,GAAG,GAAE,MAAM,MAAuC,GAChD,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,KAAK,MAAM,CAwBxC;AAED,kFAAkF;AAClF,wBAAsB,sBAAsB,CAC3C,OAAO,EAAE,mBAAmB,EAC5B,GAAG,CAAC,EAAE,MAAM,MAAM,EAClB,OAAO,CAAC,EAAE,0BAA0B,CAAC,SAAS,CAAC,GAC7C,OAAO,CAAC,wBAAwB,CAAC,CAYnC"}

package/dist/utils/daemon-stdio-timestamps.js

@@ -0,0 +1,59 @@
+/**
+ * ISO timestamps for the daemon's raw stdout/stderr.
+ *
+ * `pm daemon start` routes the detached daemon's fds 1/2 into
+ * `pm-daemon.stdout.log` / `pm-daemon.stderr.log`. Everything that lands
+ * there — the console sink of `@vibesdotdev/logging`, bare `console.log`
+ * calls, forwarded raw lines — arrives without a clock, so the file cannot
+ * answer "when did the health monitor kill mcp-server-dev" (measured
+ * 2026-09-06: 4.4MB of stderr, not one line carries a time; the structured
+ * `pm-daemon.log` that does was last written 2026-08-11).
+ *
+ * Stamping happens at the process's own write seam — the one place every
+ * sink and every stray print pass through — so no logger has to be taught.
+ */
+/**
+ * Returns a function that prefixes every line START in the chunks it sees
+ * with `<iso> `. A partial line (no trailing newline) keeps its continuation
+ * unstamped in the next chunk, so a line written in two pieces gets one stamp.
+ */
+export function createLineTimestamper(now = () => new Date().toISOString()) {
+    let atLineStart = true;
+    // Streaming, so a multi-byte character split across two chunks decodes whole.
+    const decoder = new TextDecoder();
+    return (chunk) => {
+        const text = chunk instanceof Uint8Array ? decoder.decode(chunk, { stream: true }) : chunk;
+        let out = '';
+        let index = 0;
+        while (index < text.length) {
+            if (atLineStart) {
+                out += `${now()} `;
+                atLineStart = false;
+            }
+            const newline = text.indexOf('\n', index);
+            if (newline === -1) {
+                out += text.slice(index);
+                break;
+            }
+            out += text.slice(index, newline + 1);
+            atLineStart = true;
+            index = newline + 1;
+        }
+        return out;
+    };
+}
+/** Acquire one handed host lease with independent timestamp state per channel. */
+export async function installStdioTimestamps(capture, now, consume) {
+    const stamps = { stdout: createLineTimestamper(now), stderr: createLineTimestamper(now) };
+    const encoder = new TextEncoder();
+    return capture.acquire({
+        target: 'both',
+        consoleMethods: [],
+        onConsole() { },
+        onWrite(write, forward, channel) {
+            const formatted = { bytes: encoder.encode(stamps[channel](write.bytes)), complete: write.complete };
+            return consume ? consume(formatted, forward, channel) : forward(formatted.bytes, formatted.complete);
+        }
+    });
+}
+//# sourceMappingURL=daemon-stdio-timestamps.js.map

package/dist/utils/daemon-stdio-timestamps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-stdio-timestamps.js","sourceRoot":"","sources":["../../src/utils/daemon-stdio-timestamps.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CACpC,MAAoB,GAAG,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;IAElD,IAAI,WAAW,GAAG,IAAI,CAAC;IACvB,8EAA8E;IAC9E,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;IAClC,OAAO,CAAC,KAAK,EAAE,EAAE;QAChB,MAAM,IAAI,GAAG,KAAK,YAAY,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QAC3F,IAAI,GAAG,GAAG,EAAE,CAAC;QACb,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,OAAO,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;YAC5B,IAAI,WAAW,EAAE,CAAC;gBACjB,GAAG,IAAI,GAAG,GAAG,EAAE,GAAG,CAAC;gBACnB,WAAW,GAAG,KAAK,CAAC;YACrB,CAAC;YACD,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YAC1C,IAAI,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC;gBACpB,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;gBACzB,MAAM;YACP,CAAC;YACD,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,CAAC,CAAC,CAAC;YACtC,WAAW,GAAG,IAAI,CAAC;YACnB,KAAK,GAAG,OAAO,GAAG,CAAC,CAAC;QACrB,CAAC;QACD,OAAO,GAAG,CAAC;IACZ,CAAC,CAAC;AACH,CAAC;AAED,kFAAkF;AAClF,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAC3C,OAA4B,EAC5B,GAAkB,EAClB,OAA+C;IAE/C,MAAM,MAAM,GAAG,EAAE,MAAM,EAAE,qBAAqB,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,qBAAqB,CAAC,GAAG,CAAC,EAAE,CAAC;IAC1F,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;IAClC,OAAO,OAAO,CAAC,OAAO,CAAC;QACtB,MAAM,EAAE,MAAM;QACd,cAAc,EAAE,EAAE;QAClB,SAAS,KAAI,CAAC;QACd,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO;YAC9B,MAAM,SAAS,GAAG,EAAE,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC;YACpG,OAAO,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;QACtG,CAAC;KACD,CAAC,CAAC;AACJ,CAAC"}

package/dist/utils/daemon-stop.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Stopping the PM daemon by pid, when its own `shutdown` RPC cannot.
+ *
+ * A pid file is a claim, not a fact (SPEC: "PID file is informational only"):
+ * the daemon can die and the OS can hand its pid to an unrelated process. So
+ * the CLI signals a pid only after proving it is still the daemon that wrote
+ * the pid file, and re-proves that before every signal it sends:
+ *
+ * - `socket-handshake`: the daemon answered on its socket and named this pid
+ *   (`health.pid` or the `shutdown` receipt's `ownerPid`);
+ * - `start-time`: the process holding the pid started no later than the pid
+ *   file was last written. A pid reused after the daemon died started after
+ *   the daemon wrote its pid file, so it cannot pass.
+ *
+ * The identity carries the process's start time; each signal first re-reads it
+ * and refuses on any change (the pid was reused while we waited). Anything
+ * unproven refuses `CONFLICT pm-daemon-pid-unproven` and nothing is signalled.
+ */
+import { type RuntimeRef } from '@vibesdotdev/kernel';
+export type DaemonStopRuntime = RuntimeRef;
+/** How a pid was proven to be the daemon. */
+export type DaemonPidBasis = 'socket-handshake' | 'start-time';
+/** A pid proven to be the daemon, pinned to the start time it was proven at. */
+export interface ProvenDaemonPid {
+    pid: number;
+    startMs: number;
+    basis: DaemonPidBasis;
+}
+export interface ProveDaemonPidOptions {
+    /** The pid file the pid was read from; its last write bounds the daemon's start. */
+    pidFile: string;
+    pid: number;
+    /** The pid the daemon itself named over its socket, when it answered. */
+    answeredPid?: number;
+}
+/** The resolution of a host's start-time reading: the filesystem owner's one definition (moved there with the lease queue). */
+export { START_TIME_RESOLUTION_MS } from '@vibesdotdev/filesystem';
+/**
+ * Prove `pid` is the daemon that wrote `pidFile`, or refuse typed. Returns
+ * `null` when the pid is already gone (nothing to stop).
+ */
+export declare function proveDaemonPid(runtime: DaemonStopRuntime, options: ProveDaemonPidOptions): Promise<ProvenDaemonPid | null>;
+/**
+ * Send `signal` to a proven daemon pid. Re-reads its start time first: a gone
+ * pid is `'gone'`, a changed start time refuses (the pid was reused), and a
+ * pid that disappears between the check and the signal (`ESRCH`) is `'gone'`.
+ * Every other signal failure propagates as the host reported it.
+ */
+export declare function signalProvenDaemon(runtime: DaemonStopRuntime, proven: ProvenDaemonPid, signal: 'SIGTERM' | 'SIGKILL'): Promise<'signalled' | 'gone'>;
+export interface StopProvenDaemonOptions {
+    /** The first signal: SIGTERM for a graceful stop, SIGKILL for `--force`. */
+    signal: 'SIGTERM' | 'SIGKILL';
+    /** How long to wait for exit after the first signal. */
+    graceMs: number;
+    /** How long to wait after escalating to SIGKILL. */
+    killMs: number;
+    /** Called once before escalating SIGTERM to SIGKILL. */
+    onEscalate?: () => void;
+}
+/**
+ * Signal a proven daemon pid and wait for it to exit, escalating SIGTERM to
+ * SIGKILL after `graceMs`. Each signal re-proves the pid. Resolves `true` when
+ * the pid is gone, `false` when it survived SIGKILL.
+ */
+export declare function stopProvenDaemon(runtime: DaemonStopRuntime, proven: ProvenDaemonPid, options: StopProvenDaemonOptions): Promise<boolean>;
+//# sourceMappingURL=daemon-stop.d.ts.map

package/dist/utils/daemon-stop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-stop.d.ts","sourceRoot":"","sources":["../../src/utils/daemon-stop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAQvE,MAAM,MAAM,iBAAiB,GAAG,UAAU,CAAC;AAE3C,6CAA6C;AAC7C,MAAM,MAAM,cAAc,GAAG,kBAAkB,GAAG,YAAY,CAAC;AAE/D,gFAAgF;AAChF,MAAM,WAAW,eAAe;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,cAAc,CAAC;CACtB;AAED,MAAM,WAAW,qBAAqB;IACrC,oFAAoF;IACpF,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,yEAAyE;IACzE,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,+HAA+H;AAC/H,OAAO,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAuBnE;;;GAGG;AACH,wBAAsB,cAAc,CACnC,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,qBAAqB,GAC5B,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAWjC;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACvC,OAAO,EAAE,iBAAiB,EAC1B,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,SAAS,GAAG,SAAS,GAC3B,OAAO,CAAC,WAAW,GAAG,MAAM,CAAC,CAW/B;AAED,MAAM,WAAW,uBAAuB;IACvC,4EAA4E;IAC5E,MAAM,EAAE,SAAS,GAAG,SAAS,CAAC;IAC9B,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAC;IAChB,oDAAoD;IACpD,MAAM,EAAE,MAAM,CAAC;IACf,wDAAwD;IACxD,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;CACxB;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CACrC,OAAO,EAAE,iBAAiB,EAC1B,MAAM,EAAE,eAAe,EACvB,OAAO,EAAE,uBAAuB,GAC9B,OAAO,CAAC,OAAO,CAAC,CAOlB"}

package/dist/utils/daemon-stop.js

@@ -0,0 +1,100 @@
+/**
+ * Stopping the PM daemon by pid, when its own `shutdown` RPC cannot.
+ *
+ * A pid file is a claim, not a fact (SPEC: "PID file is informational only"):
+ * the daemon can die and the OS can hand its pid to an unrelated process. So
+ * the CLI signals a pid only after proving it is still the daemon that wrote
+ * the pid file, and re-proves that before every signal it sends:
+ *
+ * - `socket-handshake`: the daemon answered on its socket and named this pid
+ *   (`health.pid` or the `shutdown` receipt's `ownerPid`);
+ * - `start-time`: the process holding the pid started no later than the pid
+ *   file was last written. A pid reused after the daemon died started after
+ *   the daemon wrote its pid file, so it cannot pass.
+ *
+ * The identity carries the process's start time; each signal first re-reads it
+ * and refuses on any change (the pid was reused while we waited). Anything
+ * unproven refuses `CONFLICT pm-daemon-pid-unproven` and nothing is signalled.
+ */
+import { CapabilityError } from '@vibesdotdev/kernel';
+import { getRuntimeProcessService } from '@vibesdotdev/kernel/process';
+import { START_TIME_RESOLUTION_MS } from '@vibesdotdev/filesystem';
+import { hasErrno, rethrowFailure } from "../helpers/failure.js";
+import { attempt } from "./attempt.js";
+import { readDaemonPidFileWrittenMs } from "./daemon-pid.js";
+import { waitForProcessExit } from "./process-tree.js";
+/** The resolution of a host's start-time reading: the filesystem owner's one definition (moved there with the lease queue). */
+export { START_TIME_RESOLUTION_MS } from '@vibesdotdev/filesystem';
+function unproven(pid, detail) {
+    return new CapabilityError(`Refusing to signal PID ${pid}: it is not proven to be the PM daemon (${detail}).`, 'CONFLICT', {
+        reason: 'pm-daemon-pid-unproven',
+        retryable: false,
+        details: { pid },
+        recoveryHint: 'The pid file may be stale and its pid reused by another process. Check the process yourself; `vibes pm daemon status` shows what PM can prove.'
+    });
+}
+/** The pid's current process start time through the handed runtime's process service; null when it is gone. */
+async function readStartMs(runtime, pid) {
+    const service = await getRuntimeProcessService(runtime);
+    if (!service.processStartMs)
+        throw unproven(pid, 'this host cannot read process start times');
+    return service.processStartMs(pid);
+}
+/**
+ * Prove `pid` is the daemon that wrote `pidFile`, or refuse typed. Returns
+ * `null` when the pid is already gone (nothing to stop).
+ */
+export async function proveDaemonPid(runtime, options) {
+    const { pid } = options;
+    const startMs = await readStartMs(runtime, pid);
+    if (startMs === null)
+        return null;
+    if (options.answeredPid === pid)
+        return { pid, startMs, basis: 'socket-handshake' };
+    const writtenMs = await readDaemonPidFileWrittenMs(runtime, options.pidFile);
+    if (writtenMs === null)
+        throw unproven(pid, 'the pid file is gone');
+    if (startMs > writtenMs + START_TIME_RESOLUTION_MS) {
+        throw unproven(pid, 'the process started after the pid file was written, so the pid was reused');
+    }
+    return { pid, startMs, basis: 'start-time' };
+}
+/**
+ * Send `signal` to a proven daemon pid. Re-reads its start time first: a gone
+ * pid is `'gone'`, a changed start time refuses (the pid was reused), and a
+ * pid that disappears between the check and the signal (`ESRCH`) is `'gone'`.
+ * Every other signal failure propagates as the host reported it.
+ */
+export async function signalProvenDaemon(runtime, proven, signal) {
+    const startMs = await readStartMs(runtime, proven.pid);
+    if (startMs === null)
+        return 'gone';
+    if (Math.abs(startMs - proven.startMs) > START_TIME_RESOLUTION_MS) {
+        throw unproven(proven.pid, 'its start time changed, so the pid was reused');
+    }
+    const service = await getRuntimeProcessService(runtime);
+    const signalled = await attempt(() => service.signal(proven.pid, signal));
+    if (signalled.ok)
+        return 'signalled';
+    if (hasErrno(signalled.failure, 'ESRCH'))
+        return 'gone';
+    return rethrowFailure(signalled.failure);
+}
+/**
+ * Signal a proven daemon pid and wait for it to exit, escalating SIGTERM to
+ * SIGKILL after `graceMs`. Each signal re-proves the pid. Resolves `true` when
+ * the pid is gone, `false` when it survived SIGKILL.
+ */
+export async function stopProvenDaemon(runtime, proven, options) {
+    if ((await signalProvenDaemon(runtime, proven, options.signal)) === 'gone')
+        return true;
+    if (await waitForProcessExit(runtime, proven.pid, options.graceMs))
+        return true;
+    if (options.signal === 'SIGKILL')
+        return false;
+    options.onEscalate?.();
+    if ((await signalProvenDaemon(runtime, proven, 'SIGKILL')) === 'gone')
+        return true;
+    return waitForProcessExit(runtime, proven.pid, options.killMs);
+}
+//# sourceMappingURL=daemon-stop.js.map

package/dist/utils/daemon-stop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-stop.js","sourceRoot":"","sources":["../../src/utils/daemon-stop.ts"],"names":[],"mappings":"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"}

package/dist/utils/errno-failure.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A caught failure that carries an errno-style `code` (`ENOENT`, `ESRCH`, …).
+ *
+ * A catch site parses its binding with `CaughtFailureSchema`, asks this guard
+ * whether the failure carries a code, and branches on `failure.code`; message
+ * text is never read. Only a confirmed absence (`ENOENT`, `ESRCH`) is
+ * treated as "not there": every other failure is rethrown by the caller.
+ */
+import type { CaughtFailure } from '@vibesdotdev/kernel';
+/** The `code` of a failure that has one (a POSIX errno, a Node `ERR_*` code, a `CapabilityError` code). */
+export type ErrnoFailure = Error & {
+    readonly code: string;
+};
+/** Whether the caught failure is an `Error` carrying a string `code`. */
+export declare function hasErrnoCode(failure: CaughtFailure): failure is ErrnoFailure;
+//# sourceMappingURL=errno-failure.d.ts.map

package/dist/utils/errno-failure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errno-failure.d.ts","sourceRoot":"","sources":["../../src/utils/errno-failure.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAKzD,2GAA2G;AAC3G,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7D,yEAAyE;AACzE,wBAAgB,YAAY,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,IAAI,YAAY,CAE5E"}

package/dist/utils/errno-failure.js

@@ -0,0 +1,15 @@
+/**
+ * A caught failure that carries an errno-style `code` (`ENOENT`, `ESRCH`, …).
+ *
+ * A catch site parses its binding with `CaughtFailureSchema`, asks this guard
+ * whether the failure carries a code, and branches on `failure.code`; message
+ * text is never read. Only a confirmed absence (`ENOENT`, `ESRCH`) is
+ * treated as "not there": every other failure is rethrown by the caller.
+ */
+import * as z from 'zod/v4';
+const ErrnoSchema = z.object({ code: z.string() });
+/** Whether the caught failure is an `Error` carrying a string `code`. */
+export function hasErrnoCode(failure) {
+    return failure instanceof Error && ErrnoSchema.safeParse(failure).success;
+}
+//# sourceMappingURL=errno-failure.js.map

package/dist/utils/errno-failure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errno-failure.js","sourceRoot":"","sources":["../../src/utils/errno-failure.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;AAKnD,yEAAyE;AACzE,MAAM,UAAU,YAAY,CAAC,OAAsB;IAClD,OAAO,OAAO,YAAY,KAAK,IAAI,WAAW,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC;AAC3E,CAAC"}

package/dist/utils/exec.d.ts

@@ -0,0 +1,27 @@
+/**
+ * PM's command helpers over the handed runtime's execution provider.
+ *
+ * `runCapture` / `runTimedCapture` run a tool PM needs for itself (`ps`,
+ * `kubectl`, `helm`, `docker`, `mkcert`): its whole environment is
+ * `resolvePMToolEnv` (the kernel's host set, the host variables the call names
+ * in `inheritEnv`, its declared `env`, and PM's PATH repair), spawned with
+ * `envMode: 'replace'`. A caller that composed a managed child's environment
+ * itself (a lifecycle hook, the daemon launch) uses the runtime helpers,
+ * re-exported here, with `envMode: 'replace'`.
+ */
+import { type RunCaptureResult, type TimedRunResult } from '@vibesdotdev/kernel/execution';
+import type { RuntimeRef } from '@vibesdotdev/kernel';
+export { spawnSupervised, spawnLogged, whichCommand, type RunCaptureResult, type RunCaptureOptions, type TimedRunResult, type SupervisedChild } from '@vibesdotdev/kernel/execution';
+/** A tool call: where it runs, what it names from the host, what it declares. */
+export interface PMToolOptions {
+    cwd?: string;
+    env?: Readonly<Record<string, string | undefined>>;
+    inheritEnv?: readonly string[];
+    stdin?: string;
+    signal?: AbortSignal;
+}
+export declare function runCapture(runtime: RuntimeRef, cmd: string, args: readonly string[], options?: PMToolOptions): Promise<RunCaptureResult>;
+export declare function runTimedCapture(runtime: RuntimeRef, cmd: string, args: readonly string[], options: PMToolOptions & {
+    timeoutMs: number;
+}): Promise<TimedRunResult>;
+//# sourceMappingURL=exec.d.ts.map

package/dist/utils/exec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec.d.ts","sourceRoot":"","sources":["../../src/utils/exec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAGN,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAGtD,OAAO,EACN,eAAe,EACf,WAAW,EACX,YAAY,EACZ,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,MAAM,+BAA+B,CAAC;AAEvC,iFAAiF;AACjF,MAAM,WAAW,aAAa;IAC7B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;IACnD,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,WAAW,CAAC;CACrB;AAED,wBAAsB,UAAU,CAC/B,OAAO,EAAE,UAAU,EACnB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,GAAE,aAAkB,GACzB,OAAO,CAAC,gBAAgB,CAAC,CAS3B;AAED,wBAAsB,eAAe,CACpC,OAAO,EAAE,UAAU,EACnB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,EAAE,aAAa,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,GAC5C,OAAO,CAAC,cAAc,CAAC,CAUzB"}

package/dist/utils/exec.js

@@ -0,0 +1,36 @@
+/**
+ * PM's command helpers over the handed runtime's execution provider.
+ *
+ * `runCapture` / `runTimedCapture` run a tool PM needs for itself (`ps`,
+ * `kubectl`, `helm`, `docker`, `mkcert`): its whole environment is
+ * `resolvePMToolEnv` (the kernel's host set, the host variables the call names
+ * in `inheritEnv`, its declared `env`, and PM's PATH repair), spawned with
+ * `envMode: 'replace'`. A caller that composed a managed child's environment
+ * itself (a lifecycle hook, the daemon launch) uses the runtime helpers,
+ * re-exported here, with `envMode: 'replace'`.
+ */
+import { runCapture as runtimeRunCapture, runTimedCapture as runtimeRunTimedCapture } from '@vibesdotdev/kernel/execution';
+import { resolvePMToolEnv } from "../helpers/process-env.js";
+export { spawnSupervised, spawnLogged, whichCommand } from '@vibesdotdev/kernel/execution';
+export async function runCapture(runtime, cmd, args, options = {}) {
+    const env = await resolvePMToolEnv(runtime, { env: options.env, inheritEnv: options.inheritEnv });
+    return runtimeRunCapture(runtime, cmd, args, {
+        cwd: options.cwd,
+        stdin: options.stdin,
+        signal: options.signal,
+        env,
+        envMode: 'replace'
+    });
+}
+export async function runTimedCapture(runtime, cmd, args, options) {
+    const env = await resolvePMToolEnv(runtime, { env: options.env, inheritEnv: options.inheritEnv });
+    return runtimeRunTimedCapture(runtime, cmd, args, {
+        cwd: options.cwd,
+        stdin: options.stdin,
+        signal: options.signal,
+        timeoutMs: options.timeoutMs,
+        env,
+        envMode: 'replace'
+    });
+}
+//# sourceMappingURL=exec.js.map

package/dist/utils/exec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec.js","sourceRoot":"","sources":["../../src/utils/exec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EACN,UAAU,IAAI,iBAAiB,EAC/B,eAAe,IAAI,sBAAsB,EAGzC,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAE7D,OAAO,EACN,eAAe,EACf,WAAW,EACX,YAAY,EAKZ,MAAM,+BAA+B,CAAC;AAWvC,MAAM,CAAC,KAAK,UAAU,UAAU,CAC/B,OAAmB,EACnB,GAAW,EACX,IAAuB,EACvB,UAAyB,EAAE;IAE3B,MAAM,GAAG,GAAG,MAAM,gBAAgB,CAAC,OAAO,EAAE,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE,UAAU,EAAE,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;IAClG,OAAO,iBAAiB,CAAC,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE;QAC5C,GAAG,EAAE,OAAO,CAAC,GAAG;QAChB,KAAK,EAAE,OAAO,CAAC,KAAK;QACpB,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,GAAG;QACH,OAAO,EAAE,SAAS;KAClB,CAAC,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,eAAe,CACpC,OAAmB,EACnB,GAAW,EACX,IAAuB,EACvB,OAA8C;IAE9C,MAAM,GAAG,GAAG,MAAM,gBAAgB,CAAC,OAAO,EAAE,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE,UAAU,EAAE,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;IAClG,OAAO,sBAAsB,CAAC,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE;QACjD,GAAG,EAAE,OAAO,CAAC,GAAG;QAChB,KAAK,EAAE,OAAO,CAAC,KAAK;QACpB,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,GAAG;QACH,OAAO,EAAE,SAAS;KAClB,CAAC,CAAC;AACJ,CAAC"}

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * PM Utilities
+ */
+export { calculateProcessVersion, formatVersion } from './version.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,uBAAuB,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC"}