@myapihq/cli 2.6.1 → 2.6.2

package/dist/commands/doctor-findings.test.js

@@ -6,7 +6,7 @@
 // OBSERVATION ("it answered 401", "the platform's counter said zero"). Each
 // test below pins the observation and refuses the conclusion.
 import { describe, it, expect } from 'vitest';
-import { classifyReachability, _setupSection } from './doctor.js';
+import { classifyReachability, _setupSection, _rewriteQuietWebhook } from './doctor.js';
 const ENTITY = { slot: 'container', name: 'skout-engine-prod' };
 describe('classifyReachability', () => {
     // The finding: two containers behind an auth boundary were reported as
@@ -98,3 +98,59 @@ describe('setup gaps are confirmed before they become instructions', () => {
         expect(setupMessages(r, { domainCount: 0 })[0].hint).toMatch(/domain register/);
     });
 });
+// ── quiet webhooks ──────────────────────────────────────────────────────────
+const QUIET = {
+    id: 'webhook_quiet/332660b11afb07c8',
+    severity: 'warn',
+    scope: 'webhook/7a56765f164d2db5',
+    entity: { slot: 'webhook', id: '0737f583', name: 'funnel-skout-app' },
+    category: 'activity',
+    message: 'no deliveries in the last 30 days',
+    hint: 'confirm the form/page is reachable and wired to this endpoint',
+};
+describe('quiet-webhook advice is replaced by delivery history', () => {
+    // The reported near-miss: this hint reads as a cleanup instruction, and the
+    // endpoint it fired on was the ingest path for a live marketing site.
+    it('never tells you to go check whether the page is wired up', () => {
+        for (const lifetime of [{ count: 0 }, { count: 3, mostRecent: '2026-07-20T10:00:00Z' }]) {
+            const out = _rewriteQuietWebhook(QUIET, lifetime);
+            expect(out.hint ?? '').not.toMatch(/confirm the form/);
+        }
+    });
+    // "No submissions in 30 days" is the expected state for anything
+    // pre-launch, so it must not imply abandonment.
+    it('reports zero lifetime deliveries as a plain observation, with no hint', () => {
+        const out = _rewriteQuietWebhook(QUIET, { count: 0 });
+        expect(out.message).toBe('no submissions since created');
+        expect(out.hint).toBeUndefined();
+    });
+    it('says quiet-not-unused when deliveries exist', () => {
+        const out = _rewriteQuietWebhook(QUIET, { count: 3, mostRecent: '2026-07-20T10:00:00Z' });
+        expect(out.message).toMatch(/3 received in total, most recent 2026-07-20/);
+        expect(out.hint).toMatch(/quiet, not unused/);
+    });
+    it('omits the date when the API did not supply one', () => {
+        const out = _rewriteQuietWebhook(QUIET, { count: 1 });
+        expect(out.message).toMatch(/1 received in total$/);
+    });
+    // Never invent a cleanup recommendation. The ask was to stop implying
+    // cleanup on a signal that cannot support it — adding a confident orphan
+    // verdict would repeat the mistake in the other direction.
+    it('never suggests deleting anything', () => {
+        for (const lifetime of [{ count: 0 }, { count: 5 }, undefined]) {
+            const out = _rewriteQuietWebhook(QUIET, lifetime);
+            expect(`${out.message} ${out.hint ?? ''}`).not.toMatch(/delet|remov|clean/i);
+        }
+    });
+    // A failed lookup is not evidence, so the backend's finding stands rather
+    // than being softened on no information.
+    it('leaves the finding untouched when the count could not be fetched', () => {
+        expect(_rewriteQuietWebhook(QUIET, undefined)).toEqual(QUIET);
+    });
+    it('preserves id, severity and entity so dedup and rendering still work', () => {
+        const out = _rewriteQuietWebhook(QUIET, { count: 2 });
+        expect(out.id).toBe(QUIET.id);
+        expect(out.severity).toBe('warn');
+        expect(out.entity).toEqual(QUIET.entity);
+    });
+});

package/dist/commands/doctor.d.ts

@@ -18,6 +18,10 @@ export interface SetupContext {
     domainCount?: number;
 }
 export declare function _setupSection(report: sdkHq.DoctorReport, ctx?: SetupContext): sdkHq.DoctorSection | null;
+export declare function _rewriteQuietWebhook(issue: sdkHq.DoctorIssue, lifetime: {
+    count: number;
+    mostRecent?: string;
+} | undefined): sdkHq.DoctorIssue;
 export declare function classifyReachability(probe: {
     status: number | null;
     error?: string;

package/dist/commands/doctor.js

@@ -17,7 +17,7 @@
 // interleave with the backend's findings.
 import { promises as dns } from 'node:dns';
 import { createHash } from 'node:crypto';
-import { hq as sdkHq, container as sdkContainer, funnel as sdkFunnel, domain as sdkDomain, email as sdkEmail } from '@myapihq/sdk';
+import { hq as sdkHq, container as sdkContainer, funnel as sdkFunnel, domain as sdkDomain, email as sdkEmail, webhook as sdkWebhook } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { info, error, printJson } from '../output.js';
 import { requireOrg } from '../helpers.js';
@@ -29,6 +29,8 @@ export const EXPOSES = [
     'GET /funnel/orgs/{org_id}/funnels/{funnel_id}/pages',
     // Best-effort read for the setup-gap mailing_address check (CAN-SPAM).
     'GET /hq/account/mailing-address',
+    // Lifetime delivery counts, to replace the 30-day 'quiet webhook' advice.
+    'GET /webhook/orgs/{org_id}/deliveries',
 ];
 export const SCHEMA = {};
 const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
@@ -336,6 +338,85 @@ async function httpProbeSection(apiKey, orgId) {
         issues,
     };
 }
+// The backend flags a webhook that has had "no deliveries in the last 30 days"
+// and hints "confirm the form/page is reachable and wired to this endpoint".
+//
+// That hint reads as a cleanup instruction, and a user came within one command
+// of deleting the endpoint behind their live marketing site because of it. The
+// 30-day window cannot support the implication: a pre-launch product has no
+// traffic by definition, which is the normal state for most forms on a
+// platform aimed at people building something new. The signal cannot tell
+// "abandoned" from "not launched".
+//
+// It is also not correlated with the thing it implies. In the reported org the
+// endpoint holding three real waitlist signups was NOT flagged, while the one
+// serving the live landing page was.
+//
+// Lifetime deliveries can tell those apart, and we can count them. So the
+// window stays as the observation, and the count replaces the advice:
+//
+//   received > 0  → quiet, not abandoned. Never imply cleanup.
+//   received = 0  → "no submissions since created" — the expected pre-launch
+//                   state. Still no directive.
+//
+// Deliberately absent: any suggestion to DELETE. The ask was to stop implying
+// cleanup on a signal that cannot support it, and inventing a
+// confident-sounding orphan verdict would repeat the mistake in the other
+// direction. State what is true and let the operator decide.
+export function _rewriteQuietWebhook(issue, lifetime) {
+    // No evidence gathered — leave the backend's finding untouched rather than
+    // soften something we did not check.
+    if (!lifetime)
+        return issue;
+    if (lifetime.count > 0) {
+        const when = lifetime.mostRecent ? `, most recent ${lifetime.mostRecent.slice(0, 10)}` : '';
+        return {
+            ...issue,
+            message: `no deliveries in the last 30 days — ${lifetime.count} received in total${when}`,
+            hint: 'quiet, not unused — this endpoint has received real submissions',
+        };
+    }
+    return {
+        ...issue,
+        message: 'no submissions since created',
+        hint: undefined,
+    };
+}
+// Walks the report's `webhook_quiet` findings and replaces the directive with
+// what the delivery history actually shows. Best-effort: any failure leaves
+// the backend's original finding in place.
+async function enrichQuietWebhooks(apiKey, orgId, report) {
+    const quiet = [];
+    for (const s of report.sections) {
+        for (const i of s.issues) {
+            if (i.id?.startsWith('webhook_quiet/') && i.entity?.id)
+                quiet.push(i);
+        }
+    }
+    if (quiet.length === 0)
+        return;
+    const byEndpoint = new Map();
+    await Promise.all([...new Set(quiet.map(i => i.entity.id))].map(async (endpointId) => {
+        try {
+            const page = await sdkWebhook.listDeliveries(apiKey, orgId, { endpointId, limit: 100 });
+            const items = page.deliveries ?? [];
+            byEndpoint.set(endpointId, {
+                // `has_more` means we counted a floor, not a total — which is fine,
+                // because every use of this number only needs "more than zero".
+                count: items.length,
+                mostRecent: items[0]?.received_at,
+            });
+        }
+        catch {
+            byEndpoint.set(endpointId, undefined);
+        }
+    }));
+    for (const s of report.sections) {
+        s.issues = s.issues.map(i => (i.id?.startsWith('webhook_quiet/') && i.entity?.id)
+            ? _rewriteQuietWebhook(i, byEndpoint.get(i.entity.id))
+            : i);
+    }
+}
 // What an HTTP status actually tells you about reachability.
 //
 // This check used to treat any status >= 400 as "unreachable" with the hint
@@ -460,6 +541,7 @@ export async function run(_subcommand, _args, flags) {
     const setup = _setupSection(report, { mailingAddress, mailboxCount, domainCount });
     if (setup)
         report.sections.push(setup);
+    await enrichQuietWebhooks(apiKey, orgId, report);
     const localSection = await dnsProbeSection(report);
     if (localSection)
         report.sections.push(localSection);

package/dist/commands/funnel.js

@@ -173,6 +173,39 @@ export async function del(id, flags) {
     await sdkFunnel.deleteFunnel(config.api_key, orgId, id);
     success(`Funnel ${id} deleted (org ${orgId})`);
 }
+// Returns the funnel's own URL when it answers with a non-empty body, else
+// null. Used only to contradict an empty page inventory, so every failure
+// mode — no URL, network error, timeout, 404, empty body — resolves to null
+// and lets the normal "no pages" message stand. A probe that cannot reach the
+// funnel is not evidence that the funnel is serving.
+async function probeFunnelOrigin(apiKey, orgId, funnelId) {
+    let url;
+    try {
+        const funnels = await sdkFunnel.listFunnels(apiKey, orgId);
+        const f = funnels.find(x => x.id === funnelId);
+        url = f?.domain_url || f?.subdomain_url;
+    }
+    catch {
+        return null;
+    }
+    if (!url)
+        return null;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 8000);
+    try {
+        const res = await fetch(url, { signal: controller.signal, redirect: 'follow' });
+        if (!res.ok)
+            return null;
+        const body = await res.text();
+        return body.trim().length > 0 ? url : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
 // List the pages currently published to a funnel. Resolves the funnel id
 // from positional arg, --funnel flag, or the user's default funnel.
 export async function pages(funnelArg, flags) {
@@ -182,6 +215,31 @@ export async function pages(funnelArg, flags) {
     if (!funnelId)
         error('Missing funnel id. Pass it as a positional arg, --funnel <id>, or set: myapi config set-funnel <id>');
     const list = await sdkFunnel.listFunnelPages(config.api_key, orgId, funnelId);
+    // An empty inventory is not proof the funnel is empty. Verified 2026-07-28:
+    // a funnel answering 200 with real content on both its subdomain and a bound
+    // custom domain reported `{"pages":[]}`. Someone auditing what is deployed
+    // reads "No pages published" as "safe to remove", and that is how a live
+    // site gets deleted by a person being careful.
+    //
+    // So when the list is empty, ask the funnel itself before agreeing it is
+    // empty. Only on the empty path — the common case costs nothing extra.
+    //
+    // This runs BEFORE the --json branch on purpose. An agent is more likely to
+    // use --json than a human is, and handing it `[]` with exit 0 is precisely
+    // the silent wrong answer. The JSON shape stays an array so existing parsers
+    // keep working; the contradiction goes to stderr and the exit code turns
+    // non-zero, so anything checking either one is protected.
+    const serving = list.length === 0
+        ? await probeFunnelOrigin(config.api_key, orgId, funnelId)
+        : null;
+    if (serving) {
+        if (flags.json)
+            printJson(list);
+        error(`Inventory reports no pages, but ${serving} is serving content right now.\n\n` +
+            'This is a reporting bug, not an empty funnel. Do NOT delete this funnel on the\n' +
+            'strength of an empty page list — confirm with curl first.');
+        return;
+    }
     if (flags.json) {
         printJson(list);
         return;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@myapihq/cli",
   "license": "Apache-2.0",
-  "version": "2.6.1",
+  "version": "2.6.2",
   "description": "MyAPI command-line interface",
   "repository": {
     "type": "git",
@@ -40,7 +40,7 @@
     "lint:skills:strict": "node scripts/copy-skills.js && node scripts/lint-skills.js --strict"
   },
   "dependencies": {
-    "@myapihq/sdk": "^2.6.1"
+    "@myapihq/sdk": "^2.6.2"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",