@prohost/cli 0.4.2 → 0.6.0

package/dist/agent/runtime_status.js

@@ -0,0 +1,556 @@
+/**
+ * Runtime, model and remaining capacity — what `agent run` tells ProhostAI about itself.
+ *
+ * ProhostAI shows every paired AI employee with its runtime ("Claude Code"),
+ * model ("Opus 5.5"), machine and how much of the operator's Claude or Codex
+ * subscription is left. Only this machine can see those things, so the harness
+ * reports them in a `runtime_status` frame on the socket it already holds.
+ *
+ * **Credentials never leave this machine, and this module never reads them.**
+ * Every number comes from the agent CLI answering with its own login:
+ *
+ * - Claude Code: the `rate_limit_event` and `system/init` lines of a run's own
+ *   `stream-json` output, and — when idle — the `get_usage` control request to
+ *   an unmodified `claude -p --input-format stream-json` (no model turn).
+ * - Codex: the rollout file Codex writes for each run under
+ *   `$CODEX_HOME/sessions`, and — when idle — `account/rateLimits/read` on
+ *   `codex app-server`.
+ *
+ * Nothing here opens the Claude Code keychain item or `~/.codex/auth.json`, and
+ * nothing forwards an account id, email or org. Only labels, percentages and
+ * reset times go on the wire. Unknown or missing data is omitted, never sent as
+ * zero.
+ *
+ * Every parser here fails soft, in the same spirit as `readClaudeStream`: the
+ * shapes belong to other tools and grow without asking us.
+ */
+import { spawn as nodeSpawn } from 'node:child_process';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+/** Feature name the server lists in `auth_ok.features` when it accepts the frame. */
+export const RUNTIME_STATUS_FEATURE = 'runtime_status';
+/** Routine report cadence while connected. */
+export const STATUS_INTERVAL_MS = 5 * 60_000;
+/**
+ * Minimum spacing between frames. The server accepts one per 30 s per socket
+ * and drops the rest; a second of margin keeps clock jitter from costing us
+ * the frame that carried a change.
+ */
+export const MIN_FRAME_SPACING_MS = 31_000;
+/** Ask the agent CLI for fresh numbers when the last ones are this old. */
+export const QUOTA_REFRESH_AFTER_MS = 15 * 60_000;
+/** Ceiling on one idle quota probe. */
+export const PROVIDER_TIMEOUT_MS = 10_000;
+/** Percent at or above which a window counts as running low / used up. */
+const LOW_PERCENT = 75;
+const EXHAUSTED_PERCENT = 100;
+// ── Small, defensive readers ───────────────────────────────────────────────
+function asObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function text(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function parseLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('{'))
+        return undefined;
+    try {
+        return asObject(JSON.parse(trimmed));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** A percentage on a 0–``scale`` scale, as 0–100 rounded to one decimal. */
+export function percent(value, scale) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return undefined;
+    const pct = value * (100 / scale);
+    return Math.min(100, Math.max(0, Math.round(pct * 10) / 10));
+}
+/** Epoch seconds or an ISO string, as ISO-8601; anything else is `undefined`. */
+export function isoTime(value) {
+    if (typeof value === 'number' && Number.isFinite(value) && value > 1e9) {
+        return new Date(value * 1000).toISOString();
+    }
+    if (typeof value === 'string' && !Number.isNaN(Date.parse(value))) {
+        return new Date(value).toISOString();
+    }
+    return undefined;
+}
+/** First `X.Y.Z…` in a `--version` line, e.g. `2.1.282 (Claude Code)` or `codex-cli 0.146.0`. */
+export function parseVersion(stdout) {
+    return /\b(\d+\.\d+\.\d+[0-9A-Za-z.+-]*)/.exec(stdout)?.[1];
+}
+// ── Claude Code ────────────────────────────────────────────────────────────
+const CLAUDE_WINDOWS = [
+    ['five_hour', 'session'],
+    ['seven_day', 'weekly'],
+];
+/**
+ * Windows from a stream `rate_limit_event.rate_limit_info`.
+ *
+ * `unifiedWindows.*.utilization` is a FRACTION (0–1, and it can exceed 1) with
+ * epoch-second resets — unlike `get_usage`, which is 0–100 with ISO strings.
+ * The field is marked internal upstream, so an unexpected shape yields nothing.
+ */
+export function fromClaudeRateLimitInfo(info) {
+    const windows = asObject(asObject(info)?.unifiedWindows) ?? {};
+    return CLAUDE_WINDOWS.flatMap(([key, kind]) => {
+        const window = asObject(windows[key]);
+        const used = percent(window?.utilization, 1);
+        const at = isoTime(window?.resetsAt);
+        return used !== undefined && at ? [{ kind, used_percent: used, resets_at: at }] : [];
+    });
+}
+/** Windows from a `get_usage` control response (0–100, ISO strings). */
+export function fromClaudeGetUsage(usage) {
+    const record = asObject(usage);
+    if (record?.rate_limits_available !== true)
+        return [];
+    const limits = asObject(record.rate_limits) ?? {};
+    return CLAUDE_WINDOWS.flatMap(([key, kind]) => {
+        const window = asObject(limits[key]);
+        const used = percent(window?.utilization, 100);
+        const at = isoTime(window?.resets_at);
+        return used !== undefined && at ? [{ kind, used_percent: used, resets_at: at }] : [];
+    });
+}
+const CLAUDE_PLANS = {
+    pro: 'Claude Pro',
+    max: 'Claude Max',
+    team: 'Claude Team',
+    enterprise: 'Claude Enterprise',
+};
+/** `get_usage.subscription_type` → display label; `undefined` for anything else. */
+export function claudePlanLabel(subscriptionType) {
+    const key = text(subscriptionType)?.toLowerCase();
+    return key ? CLAUDE_PLANS[key] : undefined;
+}
+// ── Codex ──────────────────────────────────────────────────────────────────
+/**
+ * Windows from Codex `rate_limits` (rollout, snake_case) or `rateLimits`
+ * (app-server, camelCase).
+ *
+ * Classified by window LENGTH, never by slot: on some plans `primary` is the
+ * weekly window and there is no 5-hour one at all.
+ */
+export function fromCodexRateLimits(rateLimits, lineTimestamp) {
+    const record = asObject(rateLimits);
+    if (!record)
+        return [];
+    return [record.primary, record.secondary].flatMap((raw) => {
+        const window = asObject(raw);
+        if (!window)
+            return [];
+        const minutes = window.window_minutes ?? window.windowDurationMins;
+        const kind = typeof minutes !== 'number'
+            ? undefined
+            : minutes > 0 && minutes <= 360
+                ? 'session'
+                : minutes >= 8_640 && minutes <= 11_520
+                    ? 'weekly'
+                    : undefined;
+        const used = percent(window.used_percent ?? window.usedPercent, 100);
+        let at = isoTime(window.resets_at ?? window.resetsAt);
+        // Older Codex builds said "in N seconds", relative to the line it was on.
+        if (!at && typeof window.resets_in_seconds === 'number' && lineTimestamp) {
+            const base = Date.parse(lineTimestamp);
+            if (!Number.isNaN(base))
+                at = new Date(base + window.resets_in_seconds * 1000).toISOString();
+        }
+        return kind && used !== undefined && at ? [{ kind, used_percent: used, resets_at: at }] : [];
+    });
+}
+/** `plan_type` / `planType` → `ChatGPT Pro`; `undefined` when there is no plan. */
+export function codexPlanLabel(planType) {
+    const plan = text(planType);
+    if (!plan)
+        return undefined;
+    return `ChatGPT ${plan.charAt(0).toUpperCase()}${plan.slice(1).toLowerCase()}`;
+}
+/** Model named in the exec string itself (`-m gpt-5` / `--model gpt-5` / `--model=gpt-5`). */
+export function modelFromExec(exec) {
+    const words = exec.trim().split(/\s+/);
+    for (let i = 0; i < words.length; i += 1) {
+        const word = words[i] ?? '';
+        if (word === '-m' || word === '--model')
+            return text(words[i + 1]?.replace(/^['"]|['"]$/g, ''));
+        if (word.startsWith('--model='))
+            return text(word.slice('--model='.length).replace(/^['"]|['"]$/g, ''));
+    }
+    return undefined;
+}
+/** `$CODEX_HOME`, defaulting to `~/.codex` exactly as Codex does. */
+export function codexHome(env = process.env) {
+    return env.CODEX_HOME || path.join(env.HOME || os.homedir(), '.codex');
+}
+/**
+ * The top-level `model = "…"` in `$CODEX_HOME/config.toml` — Codex's default.
+ *
+ * Only the top level, before the first `[table]`: a `model` inside a profile
+ * table is not the default. A first guess only; the rollout's `turn_context`
+ * replaces it after the first run.
+ */
+export function codexConfiguredModel(env = process.env) {
+    let content;
+    try {
+        content = readFileSync(path.join(codexHome(env), 'config.toml'), 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('['))
+            return undefined;
+        const match = /^model\s*=\s*["']([^"']+)["']/.exec(trimmed);
+        if (match)
+            return text(match[1]);
+    }
+    return undefined;
+}
+/**
+ * Locate the rollout for one thread: `sessions/YYYY/MM/DD/rollout-*-<thread_id>.jsonl`.
+ *
+ * The date directory is local time and a resumed thread lives under the day it
+ * started, so the date is never guessed — days are scanned newest first.
+ */
+export function findCodexRollout(threadId, env = process.env) {
+    if (!/^[0-9A-Za-z-]+$/.test(threadId))
+        return undefined;
+    const suffix = `-${threadId}.jsonl`;
+    const root = path.join(codexHome(env), 'sessions');
+    const children = (dir) => {
+        try {
+            return readdirSync(dir).sort().reverse();
+        }
+        catch {
+            return [];
+        }
+    };
+    for (const year of children(root)) {
+        for (const month of children(path.join(root, year))) {
+            for (const day of children(path.join(root, year, month))) {
+                const dir = path.join(root, year, month, day);
+                const hit = children(dir).find((name) => name.startsWith('rollout-') && name.endsWith(suffix));
+                if (hit)
+                    return path.join(dir, hit);
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * What a Codex rollout says: the model the turn really used (after `-m`,
+ * profiles and `-c`), the CLI version, and the last rate-limit snapshot.
+ */
+export function parseCodexRollout(content) {
+    const observed = {};
+    for (const line of content.split('\n')) {
+        const entry = parseLine(line);
+        if (!entry)
+            continue;
+        const payload = asObject(entry.payload);
+        if (!payload)
+            continue;
+        if (entry.type === 'session_meta') {
+            observed.runtime_version = text(payload.cli_version) ?? observed.runtime_version;
+        }
+        else if (entry.type === 'turn_context') {
+            observed.model = text(payload.model) ?? observed.model;
+        }
+        else if (entry.type === 'event_msg' && payload.type === 'token_count' && payload.rate_limits) {
+            // One per model response — the last one is the freshest.
+            observed.quota_windows = fromCodexRateLimits(payload.rate_limits, typeof entry.timestamp === 'string' ? entry.timestamp : undefined);
+            observed.plan_label = codexPlanLabel(asObject(payload.rate_limits)?.plan_type) ?? observed.plan_label;
+        }
+    }
+    return observed;
+}
+/** Read the rollout for a finished Codex thread, if it can be found. */
+export function readCodexObservation(threadId, env = process.env) {
+    if (!threadId)
+        return undefined;
+    const file = findCodexRollout(threadId, env);
+    if (!file || !existsSync(file))
+        return undefined;
+    try {
+        return parseCodexRollout(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Spawn ``command args``, write ``lines`` as JSONL, and resolve with the first
+ * stdout line ``pick`` accepts. Kills the child on answer, error or timeout.
+ */
+function exchangeJsonLines(spawnImpl, command, args, lines, pick, timeoutMs) {
+    return new Promise((resolve) => {
+        let settled = false;
+        let buffer = '';
+        let child;
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            try {
+                child?.kill();
+            }
+            catch {
+                /* already gone */
+            }
+            resolve(value);
+        };
+        const timer = setTimeout(() => finish(undefined), timeoutMs);
+        timer.unref?.();
+        try {
+            child = spawnImpl(command, args, { stdio: ['pipe', 'pipe', 'ignore'] });
+        }
+        catch {
+            finish(undefined);
+            return;
+        }
+        child.on('error', () => finish(undefined));
+        child.on('close', () => finish(undefined));
+        child.stdout?.setEncoding('utf8');
+        child.stdout?.on('data', (chunk) => {
+            buffer += chunk;
+            if (buffer.length > 1024 * 1024)
+                buffer = buffer.slice(-64 * 1024);
+            const parts = buffer.split('\n');
+            buffer = parts.pop() ?? '';
+            for (const part of parts) {
+                const parsed = parseLine(part);
+                if (!parsed)
+                    continue;
+                const value = pick(parsed);
+                if (value !== undefined) {
+                    finish(value);
+                    return;
+                }
+            }
+        });
+        child.stdin?.on('error', () => {
+            /* child exited before reading; `close` settles */
+        });
+        child.stdin?.write(lines.map((line) => JSON.stringify(line)).join('\n') + '\n');
+    });
+}
+/**
+ * Claude Code's `get_usage` control request. No model turn is made, so no
+ * quota is spent. The `initialize` response carries account identity; it is
+ * never read.
+ */
+export function claudeQuotaProvider(options) {
+    return {
+        refresh: () => exchangeJsonLines(options.spawnImpl ?? nodeSpawn, options.binary, ['-p', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose'], [
+            { type: 'control_request', request_id: 'prohost-init', request: { subtype: 'initialize' } },
+            {
+                type: 'control_request',
+                request_id: 'prohost-usage',
+                request: { subtype: 'get_usage', skip_behaviors: true },
+            },
+        ], (line) => {
+            if (line.type !== 'control_response')
+                return undefined;
+            const response = asObject(line.response);
+            if (response?.request_id !== 'prohost-usage')
+                return undefined;
+            if (response.subtype !== 'success')
+                return {};
+            const usage = asObject(response.response) ?? response;
+            const windows = fromClaudeGetUsage(usage);
+            return {
+                plan_label: claudePlanLabel(usage.subscription_type),
+                ...(windows.length > 0 ? { quota_windows: windows } : {}),
+            };
+        }, options.timeoutMs ?? PROVIDER_TIMEOUT_MS),
+    };
+}
+/** Codex's `account/rateLimits/read` over `codex app-server` stdio JSON-RPC. */
+export function codexQuotaProvider(options) {
+    return {
+        refresh: () => exchangeJsonLines(options.spawnImpl ?? nodeSpawn, options.binary, ['app-server'], [
+            {
+                id: 1,
+                method: 'initialize',
+                params: { clientInfo: { name: 'prohost-cli', version: options.clientVersion } },
+            },
+            { method: 'initialized' },
+            { id: 2, method: 'account/rateLimits/read' },
+        ], (line) => {
+            if (line.id !== 2)
+                return undefined;
+            const rateLimits = asObject(asObject(line.result)?.rateLimits);
+            if (!rateLimits)
+                return {};
+            const windows = fromCodexRateLimits(rateLimits);
+            return {
+                plan_label: codexPlanLabel(rateLimits.planType),
+                ...(windows.length > 0 ? { quota_windows: windows } : {}),
+            };
+        }, options.timeoutMs ?? PROVIDER_TIMEOUT_MS),
+    };
+}
+// ── The reporter ───────────────────────────────────────────────────────────
+/** Coarse capacity band: a change of band is worth a frame straight away. */
+function band(windows) {
+    const top = Math.max(0, ...(windows ?? []).map((w) => w.used_percent));
+    return top >= EXHAUSTED_PERCENT ? 2 : top >= LOW_PERCENT ? 1 : 0;
+}
+function defaultSchedule(fn, ms) {
+    const timer = setTimeout(fn, ms);
+    timer.unref?.();
+    return () => clearTimeout(timer);
+}
+/**
+ * Holds the latest runtime snapshot and decides when to send it.
+ *
+ * Sends only while attached — i.e. only on a socket whose server advertised
+ * {@link RUNTIME_STATUS_FEATURE}. Cadence: once on attach, every
+ * {@link STATUS_INTERVAL_MS}, and promptly when the model, plan or runtime
+ * version changes or capacity crosses a band — but never closer together than
+ * {@link MIN_FRAME_SPACING_MS}.
+ */
+export class RuntimeStatusReporter {
+    options;
+    now;
+    schedule;
+    state = {};
+    quotaObservedAt;
+    send;
+    lastSentAt;
+    cancelPending;
+    cancelTick;
+    refreshing;
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? Date.now;
+        this.schedule = options.schedule ?? defaultSchedule;
+    }
+    /** Merge what a source learned. Absent fields keep their previous value. */
+    observe(observation) {
+        if (!observation)
+            return;
+        const before = this.state;
+        const next = { ...before };
+        if (observation.runtime_version)
+            next.runtime_version = observation.runtime_version;
+        if (observation.model)
+            next.model = observation.model;
+        if (observation.plan_label)
+            next.plan_label = observation.plan_label;
+        if (observation.quota_windows && observation.quota_windows.length > 0) {
+            next.quota_windows = observation.quota_windows;
+            this.quotaObservedAt = this.now();
+        }
+        this.state = next;
+        const changed = next.runtime_version !== before.runtime_version ||
+            next.model !== before.model ||
+            next.plan_label !== before.plan_label ||
+            band(next.quota_windows) !== band(before.quota_windows);
+        if (changed)
+            this.sendSoon();
+    }
+    /** The model to report on a run's completion, when nothing more specific is known. */
+    model() {
+        return this.state.model;
+    }
+    /** Start reporting on a socket that advertised the feature. */
+    attach(send) {
+        this.detach();
+        this.send = send;
+        this.lastSentAt = undefined;
+        void this.tick();
+    }
+    /** Stop reporting — the socket is gone. */
+    detach() {
+        this.send = undefined;
+        this.cancelPending?.();
+        this.cancelPending = undefined;
+        this.cancelTick?.();
+        this.cancelTick = undefined;
+    }
+    /** The frame as it would be sent now. */
+    frame() {
+        const nowMs = this.now();
+        // A window whose reset has passed describes a period that is over.
+        const windows = (this.state.quota_windows ?? []).filter((w) => Date.parse(w.resets_at) > nowMs);
+        return {
+            type: 'runtime_status',
+            runtime: this.options.runtime,
+            runtime_version: this.state.runtime_version ?? null,
+            model: this.state.model ?? null,
+            plan_label: this.state.plan_label ?? null,
+            quota_windows: windows,
+            observed_at: new Date(nowMs).toISOString(),
+        };
+    }
+    /** Routine tick: refresh idle quota if it is stale, send, and re-arm. */
+    async tick() {
+        if (!this.send)
+            return;
+        const stale = this.quotaObservedAt === undefined || this.now() - this.quotaObservedAt >= QUOTA_REFRESH_AFTER_MS;
+        const sentBefore = this.lastSentAt;
+        if (stale && this.options.provider && !this.options.isBusy?.()) {
+            await this.refresh();
+        }
+        if (!this.send)
+            return;
+        // A refresh that changed something has already sent (or queued) a frame.
+        if (this.lastSentAt === sentBefore)
+            this.sendSoon();
+        this.cancelTick?.();
+        this.cancelTick = this.schedule(() => void this.tick(), this.options.intervalMs ?? STATUS_INTERVAL_MS);
+    }
+    refresh() {
+        if (!this.refreshing) {
+            const provider = this.options.provider;
+            this.refreshing = (provider ? provider.refresh() : Promise.resolve(undefined))
+                .then((observed) => {
+                // `observe` would itself schedule a send on a change; the caller
+                // sends right after, which the spacing rule coalesces.
+                this.observe(observed);
+            })
+                .catch(() => {
+                /* fail soft — keep what we had */
+            })
+                .finally(() => {
+                this.refreshing = undefined;
+            });
+        }
+        return this.refreshing;
+    }
+    /** Send now if spacing allows, else once it does. Coalesces. */
+    sendSoon() {
+        if (!this.send || this.cancelPending)
+            return;
+        const wait = this.lastSentAt === undefined ? 0 : this.lastSentAt + MIN_FRAME_SPACING_MS - this.now();
+        if (wait <= 0) {
+            this.flush();
+            return;
+        }
+        this.cancelPending = this.schedule(() => {
+            this.cancelPending = undefined;
+            this.flush();
+        }, wait);
+    }
+    flush() {
+        if (!this.send)
+            return;
+        try {
+            this.send(this.frame());
+            this.lastSentAt = this.now();
+        }
+        catch (err) {
+            this.options.log?.(`runtime status not sent: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}

package/dist/listen.d.ts

@@ -31,12 +31,19 @@ export interface ListenOptions {
      * and the final status has been emitted.
      */
     signal?: AbortSignal;
+    /**
+     * How long the server may go silent before the socket is torn down.
+     * Defaults to {@link PING_LIVENESS_MS}; tests shorten it.
+     */
+    livenessTimeoutMs?: number;
 }
 export interface ListenMetrics {
     connected: boolean;
     eventsReceived: number;
     eventsForwarded: number;
     forwardErrors: number;
+    /** Set when the listener ended because the server went silent, not because it closed. */
+    livenessTimeout?: boolean;
 }
 /**
  * `/ws/webhooks` is served by **api_public**, which is `connect.prohost.ai` —

package/dist/listen.js

@@ -5,6 +5,8 @@
 import os from 'node:os';
 import WebSocket from 'ws';
 import { forwardEvent, isWebhookEvent } from './forward.js';
+import { ServerLiveness, enableTcpKeepAlive, seconds, terminateSocket } from './liveness.js';
+import { CLI_VERSION, USER_AGENT } from './version.js';
 /**
  * `/ws/webhooks` is served by **api_public**, which is `connect.prohost.ai` —
  * the same host as {@link DEFAULT_API_BASE_URL}. It is NOT on `api.prohost.ai`
@@ -35,7 +37,7 @@ export async function runListen(options) {
         eventsForwarded: 0,
         forwardErrors: 0,
     };
-    const ws = new Ctor(url);
+    const ws = new Ctor(url, { headers: { 'User-Agent': USER_AGENT } });
     return new Promise((resolve) => {
         const status = () => {
             const dot = metrics.connected ? '\u25CF' : '\u25CB';
@@ -55,11 +57,27 @@ export async function runListen(options) {
             else
                 options.signal.addEventListener('abort', closeWith, { once: true });
         }
+        // Same contract as the agent harness (see `liveness.ts`): the server's
+        // 60 s reaper cannot close a socket whose FIN never reached us, so keep a
+        // client-side deadline. `listen` has no reconnect loop \u2014 it resolves on
+        // close and the operator restarts it \u2014 so this ends the session with a
+        // reason on screen instead of a counter that silently stopped moving.
+        const liveness = new ServerLiveness({
+            timeoutMs: options.livenessTimeoutMs,
+            onSilence: (silentMs) => {
+                metrics.livenessTimeout = true;
+                onStatus(`\n\u2026 no server ping for ${seconds(silentMs)}s \u2014 connection lost\n`);
+                terminateSocket(ws);
+            },
+        });
         ws.on('open', () => {
+            enableTcpKeepAlive(ws);
+            liveness.start();
             const authFrame = {
                 type: 'auth',
                 api_key: options.apiKey,
                 machine,
+                client_version: CLI_VERSION,
                 ...(options.subscriptionId ? { subscription_id: options.subscriptionId } : {}),
             };
             ws.send(JSON.stringify(authFrame));
@@ -70,11 +88,15 @@ export async function runListen(options) {
                 frame = JSON.parse(data.toString());
             }
             catch {
+                liveness.observe(undefined);
                 return;
             }
-            if (!frame || typeof frame !== 'object')
+            if (!frame || typeof frame !== 'object') {
+                liveness.observe(undefined);
                 return;
+            }
             const f = frame;
+            liveness.observe(f.type);
             if (f.type === 'auth_ok') {
                 metrics.connected = true;
                 status();
@@ -114,6 +136,7 @@ export async function runListen(options) {
             }
         });
         ws.on('close', () => {
+            liveness.stop();
             metrics.connected = false;
             status();
             resolve(metrics);