@mnemom/mnemom 0.10.0 → 0.12.0

package/dist/commands/governance.js

@@ -0,0 +1,329 @@
+/**
+ * `mnemom governance` — operator CLI for governance signals (ADR-048).
+ *
+ * Subcommands:
+ *
+ *   signals      list | show | ack | resolve | dismiss
+ *   destinations list | add | remove | test
+ *   rules        list | add | remove
+ *
+ * The signal surface is operator-actionable: cron-driven sideband
+ * detections, future protection / posture observations. Distinct from
+ * `mnemom advisories list` (now narrowed to runtime.* / manual.* per
+ * ADR-048 §1).
+ */
+import chalk from "chalk";
+import { acknowledgeGovernanceSignal, createGovernanceDestination, createGovernanceRule, deleteGovernanceDestination, deleteGovernanceRule, dismissGovernanceSignal, getGovernanceSignal, listGovernanceDestinations, listGovernanceRules, listGovernanceSignalsForAgent, listGovernanceSignalsForOrg, listGovernanceSignalsForTeam, resolveGovernanceSignal, testGovernanceDestination, } from "../lib/api.js";
+import { requireAuth } from "../lib/auth.js";
+// ─── Formatting helpers ──────────────────────────────────────────────────
+function shortId(id) {
+    return id.length <= 16 ? id : id.slice(0, 13) + "...";
+}
+function severityColor(s) {
+    switch (s) {
+        case "critical":
+            return chalk.bgRed.white;
+        case "high":
+            return chalk.red;
+        case "warn":
+            return chalk.yellow;
+        default:
+            return chalk.cyan;
+    }
+}
+function statusBadge(s) {
+    switch (s) {
+        case "open":
+            return chalk.bold.red("OPEN");
+        case "acknowledged":
+            return chalk.yellow("ACK");
+        case "resolved":
+            return chalk.green("RESOLVED");
+        case "dismissed":
+            return chalk.dim("DISMISSED");
+        case "expired":
+            return chalk.dim("expired");
+        default:
+            return chalk.dim(s.toUpperCase());
+    }
+}
+function formatSignalRow(s) {
+    const sev = severityColor(s.severity)(s.severity.toUpperCase().padEnd(8));
+    return [
+        chalk.dim(shortId(s.id).padEnd(16)),
+        sev,
+        chalk.cyan(s.source.padEnd(22)),
+        chalk.magenta((s.pattern_type || "—").slice(0, 28).padEnd(28)),
+        statusBadge(s.status).padEnd(20),
+        chalk.dim(s.detected_at.replace("T", " ").replace(/\.\d+Z$/, "Z")),
+    ].join("  ");
+}
+// ─── signals list ────────────────────────────────────────────────────────
+export async function governanceSignalsListCommand(opts) {
+    await requireAuth();
+    const filters = {
+        source: opts.source,
+        severity: opts.severity,
+        status: opts.status,
+        scope: opts.scope,
+        pattern_type: opts.patternType,
+        since: opts.since,
+        limit: opts.limit ? parseInt(opts.limit, 10) : 100,
+    };
+    let result;
+    if (opts.org) {
+        result = await listGovernanceSignalsForOrg(opts.org, filters);
+    }
+    else if (opts.team) {
+        result = await listGovernanceSignalsForTeam(opts.team, filters);
+    }
+    else if (opts.agent) {
+        result = await listGovernanceSignalsForAgent(opts.agent, filters);
+    }
+    else {
+        throw new Error("One of --org, --team, --agent is required.");
+    }
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    const signals = result.signals;
+    if (signals.length === 0) {
+        console.log(chalk.dim("(no governance signals match)"));
+        return;
+    }
+    console.log([
+        chalk.bold("ID".padEnd(16)),
+        chalk.bold("SEVERITY".padEnd(8)),
+        chalk.bold("SOURCE".padEnd(22)),
+        chalk.bold("PATTERN".padEnd(28)),
+        chalk.bold("STATUS".padEnd(20)),
+        chalk.bold("DETECTED"),
+    ].join("  "));
+    for (const s of signals)
+        console.log(formatSignalRow(s));
+    console.log("");
+    console.log(chalk.dim(`${signals.length} signal(s).`));
+}
+// ─── signals show ────────────────────────────────────────────────────────
+export async function governanceSignalsShowCommand(signalId, opts) {
+    await requireAuth();
+    const signal = await getGovernanceSignal(signalId);
+    if (opts.json) {
+        console.log(JSON.stringify(signal, null, 2));
+        return;
+    }
+    console.log(chalk.bold(`Signal ${signal.id}`));
+    console.log(`  scope:     ${signal.scope} (${signal.scope_id})`);
+    console.log(`  source:    ${chalk.cyan(signal.source)}`);
+    console.log(`  pattern:   ${chalk.magenta(signal.pattern_type)}`);
+    console.log(`  severity:  ${severityColor(signal.severity)(signal.severity)}`);
+    console.log(`  status:    ${statusBadge(signal.status)}`);
+    console.log(`  detected:  ${signal.detected_at} by ${signal.detected_by}`);
+    console.log(`  org:       ${signal.org_id}`);
+    if (signal.team_id)
+        console.log(`  team:      ${signal.team_id}`);
+    console.log(`  agents:    ${signal.agent_ids.length === 0 ? "(none)" : signal.agent_ids.join(", ")}`);
+    if (signal.acknowledged_at) {
+        console.log(`  ack:       ${signal.acknowledged_at} (${signal.acknowledged_actor_role ?? "?"})${signal.acknowledged_by ? ` by ${signal.acknowledged_by}` : ""}`);
+    }
+    if (signal.resolved_at) {
+        console.log(`  resolved:  ${signal.resolved_at} (${signal.resolution_status ?? "?"})${signal.action_taken ? ` — ${signal.action_taken}` : ""}`);
+    }
+    if (Object.keys(signal.detail ?? {}).length > 0) {
+        console.log(chalk.dim("  detail:"));
+        console.log(JSON.stringify(signal.detail, null, 2)
+            .split("\n")
+            .map((l) => "    " + l)
+            .join("\n"));
+    }
+}
+// ─── signals ack/resolve/dismiss ─────────────────────────────────────────
+export async function governanceSignalsAckCommand(signalId, opts) {
+    await requireAuth();
+    const signal = await acknowledgeGovernanceSignal(signalId, {
+        action_taken: opts.action,
+    });
+    if (opts.json) {
+        console.log(JSON.stringify(signal, null, 2));
+        return;
+    }
+    console.log(chalk.green(`✓ Acknowledged ${signal.id} as ${signal.acknowledged_actor_role}.`));
+}
+export async function governanceSignalsResolveCommand(signalId, opts) {
+    await requireAuth();
+    const valid = [
+        "action_taken",
+        "wont_fix",
+        "duplicate",
+        "false_positive",
+        "self_resolved",
+    ];
+    if (!valid.includes(opts.status)) {
+        throw new Error(`--status must be one of: ${valid.join(", ")}`);
+    }
+    const signal = await resolveGovernanceSignal(signalId, {
+        resolution_status: opts.status,
+        action_taken: opts.action,
+    });
+    if (opts.json) {
+        console.log(JSON.stringify(signal, null, 2));
+        return;
+    }
+    console.log(chalk.green(`✓ Resolved ${signal.id} (${signal.resolution_status}).`));
+}
+export async function governanceSignalsDismissCommand(signalId, opts) {
+    await requireAuth();
+    const signal = await dismissGovernanceSignal(signalId, { reason: opts.reason });
+    if (opts.json) {
+        console.log(JSON.stringify(signal, null, 2));
+        return;
+    }
+    console.log(chalk.dim(`✓ Dismissed ${signal.id}.`));
+}
+// ─── destinations ────────────────────────────────────────────────────────
+function formatDestinationRow(d) {
+    return [
+        chalk.dim(shortId(d.id).padEnd(16)),
+        chalk.cyan(d.channel.padEnd(10)),
+        (d.display_name ?? "(unnamed)").slice(0, 32).padEnd(32),
+        d.enabled ? chalk.green("enabled") : chalk.dim("disabled"),
+        d.last_test_status === "ok"
+            ? chalk.green(`tested ✓ ${d.last_tested_at?.slice(0, 19) ?? ""}`)
+            : d.last_test_status === "failed"
+                ? chalk.red(`tested ✗ ${d.last_test_error?.slice(0, 64) ?? ""}`)
+                : chalk.dim("untested"),
+    ].join("  ");
+}
+export async function governanceDestinationsListCommand(opts) {
+    await requireAuth();
+    const result = await listGovernanceDestinations(opts.org);
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (result.destinations.length === 0) {
+        console.log(chalk.dim("(no destinations configured for this org)"));
+        return;
+    }
+    for (const d of result.destinations)
+        console.log(formatDestinationRow(d));
+}
+export async function governanceDestinationsAddCommand(opts) {
+    await requireAuth();
+    const validChannels = ["webhook", "slack", "email", "pagerduty"];
+    if (!validChannels.includes(opts.channel)) {
+        throw new Error(`--channel must be one of: ${validChannels.join(", ")}`);
+    }
+    let config;
+    try {
+        config = JSON.parse(opts.config);
+    }
+    catch {
+        throw new Error("--config must be valid JSON");
+    }
+    let filter;
+    if (opts.filter) {
+        try {
+            filter = JSON.parse(opts.filter);
+        }
+        catch {
+            throw new Error("--filter must be valid JSON");
+        }
+    }
+    const dest = await createGovernanceDestination(opts.org, {
+        channel: opts.channel,
+        config,
+        filter,
+        display_name: opts.name,
+    });
+    if (opts.json) {
+        console.log(JSON.stringify(dest, null, 2));
+        return;
+    }
+    console.log(chalk.green(`✓ Created destination ${dest.id} (${dest.channel}).`));
+}
+export async function governanceDestinationsRemoveCommand(destinationId, opts) {
+    await requireAuth();
+    await deleteGovernanceDestination(opts.org, destinationId);
+    if (opts.json) {
+        console.log(JSON.stringify({ ok: true, removed: destinationId }, null, 2));
+        return;
+    }
+    console.log(chalk.green(`✓ Removed destination ${destinationId}.`));
+}
+export async function governanceDestinationsTestCommand(destinationId, opts) {
+    await requireAuth();
+    const result = await testGovernanceDestination(opts.org, destinationId);
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (result.result.ok) {
+        console.log(chalk.green(`✓ Test signal delivered via ${result.channel} (${result.result.attempts} attempt).`));
+    }
+    else {
+        console.log(chalk.red(`✗ Test failed via ${result.channel}: ${result.result.last_error ?? "unknown"}`));
+        process.exitCode = 1;
+    }
+}
+// ─── rules ───────────────────────────────────────────────────────────────
+function formatRuleRow(r) {
+    return [
+        chalk.dim(shortId(r.id).padEnd(16)),
+        r.name.slice(0, 32).padEnd(32),
+        r.enabled ? chalk.green("enabled") : chalk.dim("disabled"),
+        chalk.dim(`fired ${r.fire_count}×`),
+        r.last_fired_at ? chalk.dim(`last ${r.last_fired_at.slice(0, 19)}`) : "",
+    ].join("  ");
+}
+export async function governanceRulesListCommand(opts) {
+    await requireAuth();
+    const result = await listGovernanceRules(opts.org);
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (result.rules.length === 0) {
+        console.log(chalk.dim("(no escalation rules configured for this org)"));
+        return;
+    }
+    for (const r of result.rules)
+        console.log(formatRuleRow(r));
+}
+export async function governanceRulesAddCommand(opts) {
+    await requireAuth();
+    let predicate;
+    try {
+        predicate = JSON.parse(opts.predicate);
+    }
+    catch {
+        throw new Error("--predicate must be valid JSON");
+    }
+    const destinationIds = opts.destinations
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    if (destinationIds.length === 0) {
+        throw new Error("--destinations must list at least one destination ID (comma-separated)");
+    }
+    const rule = await createGovernanceRule(opts.org, {
+        name: opts.name,
+        predicate,
+        destination_ids: destinationIds,
+    });
+    if (opts.json) {
+        console.log(JSON.stringify(rule, null, 2));
+        return;
+    }
+    console.log(chalk.green(`✓ Created rule ${rule.id} ("${rule.name}").`));
+}
+export async function governanceRulesRemoveCommand(ruleId, opts) {
+    await requireAuth();
+    await deleteGovernanceRule(opts.org, ruleId);
+    if (opts.json) {
+        console.log(JSON.stringify({ ok: true, removed: ruleId }, null, 2));
+        return;
+    }
+    console.log(chalk.green(`✓ Removed rule ${ruleId}.`));
+}

package/dist/commands/integrity.js

@@ -1,5 +1,4 @@
-import { resolveAgentId } from "../lib/api.js";
-import { getIntegrity } from "../lib/api.js";
+import { resolveAgentId, getIntegrity } from "../lib/api.js";
 import { fmt } from "../lib/format.js";
 export async function integrityCommand(agentName) {
     const agentId = await resolveAgentId(agentName);

package/dist/commands/license.js

@@ -72,10 +72,15 @@ export async function licenseActivateCommand(jwt) {
     saveLicenseJwt(jwt);
     // Display info
     const expiresAt = claims.exp ? new Date(claims.exp * 1000) : null;
-    const daysRemaining = expiresAt ? Math.floor((expiresAt.getTime() - Date.now()) / 86400000) : "unknown";
+    const daysRemaining = expiresAt
+        ? Math.floor((expiresAt.getTime() - Date.now()) / 86400000)
+        : "unknown";
     console.log("  License ID:      " + (claims.license_id || "unknown"));
     console.log("  Plan:            " + (claims.plan_id || "unknown"));
-    console.log("  Features:        " + Object.keys(claims.feature_flags || {}).filter((k) => claims.feature_flags[k]).join(", ") || "none");
+    console.log("  Features:        " +
+        Object.keys(claims.feature_flags || {})
+            .filter((k) => claims.feature_flags[k])
+            .join(", ") || "none");
     console.log("  Expires:         " + (expiresAt ? expiresAt.toISOString() : "unknown"));
     console.log("  Days remaining:  " + daysRemaining);
     console.log("  Max activations: " + (claims.max_activations || "unknown"));
@@ -95,14 +100,18 @@ export async function licenseStatusCommand() {
         process.exit(1);
     }
     const expiresAt = claims.exp ? new Date(claims.exp * 1000) : null;
-    const daysRemaining = expiresAt ? Math.floor((expiresAt.getTime() - Date.now()) / 86400000) : null;
+    const daysRemaining = expiresAt
+        ? Math.floor((expiresAt.getTime() - Date.now()) / 86400000)
+        : null;
     const isExpired = daysRemaining !== null && daysRemaining <= 0;
     console.log(fmt.header("Enterprise License Status"));
     console.log();
     console.log(`  ${fmt.label("License ID:     ", String(claims.license_id || "unknown"))}`);
     console.log(`  ${fmt.label("Account:        ", String(claims.account_id || "unknown"))}`);
     console.log(`  ${fmt.label("Plan:           ", String(claims.plan_id || "unknown"))}`);
-    console.log(`  ${fmt.label("Features:       ", Object.keys(claims.feature_flags || {}).filter((k) => claims.feature_flags[k]).join(", ") || "none")}`);
+    console.log(`  ${fmt.label("Features:       ", Object.keys(claims.feature_flags || {})
+        .filter((k) => claims.feature_flags[k])
+        .join(", ") || "none")}`);
     console.log(`  ${fmt.label("Expires:        ", expiresAt ? expiresAt.toISOString() : "unknown")}`);
     console.log(`  ${fmt.label("Days remaining: ", String(daysRemaining ?? "unknown"))}`);
     console.log(`  ${fmt.label("Status:         ", isExpired ? "EXPIRED" : "Active")}`);

package/dist/commands/listen.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `mnemom listen <org_id>` — Stripe-style live webhook event stream
+ * (Track 2 W3.4b).
+ *
+ *   mnemom listen <org_id>
+ *     [--forward-to <url>]    # POST each event to this local URL
+ *     [--secret <hex>]        # local signing secret for re-signed HMAC
+ *     [--filter <a,b,c>]      # only forward/print these event types
+ *     [--since <event_id>]    # resume from this cursor on first connect
+ *     [--json]                # emit raw JSON lines instead of formatted summary
+ *
+ * Connects to `${API_BASE}/v1/orgs/${orgId}/webhooks/listen` (SSE)
+ * and reconnects with `Last-Event-ID` on stream close. Each event is
+ * printed (formatted summary or raw JSON) and, if `--forward-to` is
+ * set, re-signed with the local secret and POST'd to the receiver
+ * URL — letting customers write/test webhook receivers locally
+ * against real production events.
+ */
+interface ListenOptions {
+    forwardTo?: string;
+    secret?: string;
+    filter?: string;
+    since?: string;
+    json?: boolean;
+    /** Test-mode hook: forces a single iteration (no reconnect loop). */
+    __once?: boolean;
+}
+export declare function listenCommand(orgId: string, opts?: ListenOptions): Promise<void>;
+export {};

package/dist/commands/listen.js

@@ -0,0 +1,201 @@
+/**
+ * `mnemom listen <org_id>` — Stripe-style live webhook event stream
+ * (Track 2 W3.4b).
+ *
+ *   mnemom listen <org_id>
+ *     [--forward-to <url>]    # POST each event to this local URL
+ *     [--secret <hex>]        # local signing secret for re-signed HMAC
+ *     [--filter <a,b,c>]      # only forward/print these event types
+ *     [--since <event_id>]    # resume from this cursor on first connect
+ *     [--json]                # emit raw JSON lines instead of formatted summary
+ *
+ * Connects to `${API_BASE}/v1/orgs/${orgId}/webhooks/listen` (SSE)
+ * and reconnects with `Last-Event-ID` on stream close. Each event is
+ * printed (formatted summary or raw JSON) and, if `--forward-to` is
+ * set, re-signed with the local secret and POST'd to the receiver
+ * URL — letting customers write/test webhook receivers locally
+ * against real production events.
+ */
+import { getApiUrl } from "../lib/config.js";
+import { resolveAuth, forceRefreshAccessToken, requireAuth } from "../lib/auth.js";
+import { fmt } from "../lib/format.js";
+import { parseSseStream, reSignDelivery } from "../lib/listen-stream.js";
+const API_BASE = getApiUrl();
+async function authHeaders() {
+    const cred = await resolveAuth();
+    switch (cred.type) {
+        case "jwt":
+            return { Authorization: `Bearer ${cred.token}` };
+        case "api-key":
+            return { "X-Mnemom-Api-Key": cred.key };
+        case "none":
+            return {};
+    }
+}
+function parseFilter(value) {
+    if (!value)
+        return null;
+    const set = new Set(value
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean));
+    return set.size > 0 ? set : null;
+}
+async function forwardEvent(url, rawBody, signingSecret, eventId) {
+    const start = Date.now();
+    const { timestamp, signature } = reSignDelivery(rawBody, signingSecret);
+    try {
+        const res = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-Webhook-Id": eventId,
+                "X-Webhook-Timestamp": timestamp,
+                "X-Webhook-Signature": signature,
+            },
+            body: rawBody,
+        });
+        return { status: res.status, latencyMs: Date.now() - start };
+    }
+    catch (err) {
+        return {
+            status: null,
+            error: err instanceof Error ? err.message : String(err),
+            latencyMs: Date.now() - start,
+        };
+    }
+}
+function summarizeEvent(eventId, eventType, fwd) {
+    const ts = new Date().toISOString().slice(11, 19);
+    if (!fwd)
+        return `[${ts}] ${eventType.padEnd(30)} ${eventId}`;
+    const statusStr = fwd.status !== null ? String(fwd.status) : "ERR";
+    const okSign = fwd.status !== null && fwd.status >= 200 && fwd.status < 300 ? "✓" : "✗";
+    return (`[${ts}] ${eventType.padEnd(30)} ${eventId.padEnd(24)} → ${okSign} ${statusStr} (${fwd.latencyMs}ms)` +
+        (fwd.error ? ` ${fwd.error}` : ""));
+}
+/**
+ * One connect → consume cycle. Returns the cursor after the cycle ends
+ * (either from the `close` event or from the last received event_id),
+ * so callers can reconnect with it.
+ */
+async function consumeOnce(orgId, cursor, opts, filter, log) {
+    const url = new URL(`${API_BASE}/v1/orgs/${orgId}/webhooks/listen`);
+    if (cursor)
+        url.searchParams.set("since", cursor);
+    const headers = {
+        ...(await authHeaders()),
+        Accept: "text/event-stream",
+    };
+    if (cursor)
+        headers["Last-Event-ID"] = cursor;
+    let res = await fetch(url.toString(), { headers });
+    if (res.status === 401) {
+        const refreshed = await forceRefreshAccessToken();
+        if (refreshed) {
+            const retryHeaders = {
+                ...(await authHeaders()),
+                Accept: "text/event-stream",
+                ...(cursor ? { "Last-Event-ID": cursor } : {}),
+            };
+            res = await fetch(url.toString(), { headers: retryHeaders });
+        }
+    }
+    if (!res.ok) {
+        const msg = await res.text().catch(() => "");
+        throw new Error(`${res.status} ${msg.slice(0, 200)}`);
+    }
+    if (!res.body)
+        throw new Error("response body missing");
+    let latestCursor = cursor;
+    for await (const frame of parseSseStream(res.body)) {
+        if (frame.event === "ready") {
+            // Connection healthy; nothing to print.
+            continue;
+        }
+        if (frame.event === "close") {
+            // Server-initiated graceful close; cursor in the data.
+            try {
+                const parsed = JSON.parse(frame.data);
+                if (parsed.cursor)
+                    latestCursor = parsed.cursor;
+            }
+            catch {
+                /* fall through */
+            }
+            return latestCursor;
+        }
+        if (frame.event === "error") {
+            log(fmt.error(`server error frame: ${frame.data}`));
+            continue;
+        }
+        if (frame.event !== "webhook.event")
+            continue;
+        let payload;
+        try {
+            payload = JSON.parse(frame.data);
+        }
+        catch {
+            log(fmt.warn(`skipped unparseable data: ${frame.data.slice(0, 80)}`));
+            continue;
+        }
+        if (filter && payload.event_type && !filter.has(payload.event_type))
+            continue;
+        if (frame.id)
+            latestCursor = frame.id;
+        if (opts.json) {
+            log(frame.data);
+        }
+        let fwdResult = null;
+        if (opts.forwardTo) {
+            if (!opts.secret) {
+                log(fmt.error("--forward-to requires --secret to re-sign the local delivery"));
+            }
+            else {
+                fwdResult = await forwardEvent(opts.forwardTo, frame.data, opts.secret, payload.event_id ?? "unknown");
+            }
+        }
+        if (!opts.json) {
+            log(summarizeEvent(payload.event_id ?? "unknown", payload.event_type ?? "?", fwdResult));
+        }
+    }
+    return latestCursor;
+}
+const RECONNECT_BACKOFF_MS = [1000, 2000, 5000, 10000];
+export async function listenCommand(orgId, opts = {}) {
+    await requireAuth();
+    if (!orgId) {
+        console.log(fmt.error("Usage: mnemom listen <org_id>") + "\n");
+        process.exit(1);
+    }
+    const filter = parseFilter(opts.filter);
+    let cursor = opts.since ?? null;
+    if (!opts.json) {
+        const filterStr = filter ? ` (filter: ${[...filter].join(", ")})` : "";
+        const forwardStr = opts.forwardTo ? `\n  Forward → ${opts.forwardTo}` : "";
+        console.log(fmt.header(`Listening for webhook events — org ${orgId}${filterStr}`) +
+            forwardStr +
+            "\n  Press Ctrl-C to stop." +
+            "\n");
+    }
+    let consecutiveFailures = 0;
+    while (true) {
+        try {
+            const next = await consumeOnce(orgId, cursor, opts, filter, (msg) => console.log(msg));
+            cursor = next;
+            consecutiveFailures = 0;
+            if (opts.__once)
+                return;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.log(fmt.warn(`Stream closed: ${msg}`));
+            if (opts.__once)
+                return;
+            const delay = RECONNECT_BACKOFF_MS[Math.min(consecutiveFailures, RECONNECT_BACKOFF_MS.length - 1)];
+            console.log(fmt.warn(`Reconnecting in ${delay}ms…`));
+            await new Promise((r) => setTimeout(r, delay));
+            consecutiveFailures += 1;
+        }
+    }
+}

package/dist/commands/logs.js

@@ -36,9 +36,7 @@ export async function logsCommand(options = {}) {
 }
 function displayTrace(trace) {
     const timestamp = formatTimestamp(trace.timestamp);
-    const statusMsg = trace.verified
-        ? fmt.success(timestamp)
-        : fmt.error(`${timestamp} [VIOLATION]`);
+    const statusMsg = trace.verified ? fmt.success(timestamp) : fmt.error(`${timestamp} [VIOLATION]`);
     console.log(`\n  ${statusMsg}`);
     console.log(`  ${fmt.label("Action:", ` ${trace.action}`)}`);
     if (trace.tool_name) {

package/dist/commands/org.js

@@ -34,10 +34,7 @@ export async function orgListCommand(opts) {
     const idW = 24;
     const roleW = 10;
     const ownerW = 8;
-    const header = "Name".padEnd(nameW) +
-        "ID".padEnd(idW) +
-        "Role".padEnd(roleW) +
-        "Owner".padEnd(ownerW);
+    const header = "Name".padEnd(nameW) + "ID".padEnd(idW) + "Role".padEnd(roleW) + "Owner".padEnd(ownerW);
     console.log(`  ${header}`);
     console.log(`  ${"─".repeat(nameW + idW + roleW + ownerW)}`);
     for (const org of orgs) {
@@ -60,7 +57,7 @@ export async function orgListCommand(opts) {
  */
 export async function orgShowCommand(orgIdArg, opts) {
     await requireAuth();
-    let target = null;
+    let target;
     try {
         if (opts.personal) {
             const ref = await getMyPersonalOrg();
@@ -81,7 +78,8 @@ export async function orgShowCommand(orgIdArg, opts) {
                 target = orgs[0];
             }
             else {
-                console.log(fmt.warn(`You have ${orgs.length} memberships. Specify an org_id or pass --personal.`) + "\n");
+                console.log(fmt.warn(`You have ${orgs.length} memberships. Specify an org_id or pass --personal.`) +
+                    "\n");
                 process.exit(1);
                 return;
             }