@danceiny/gotry 0.0.1-rc.9 → 0.2.0-rc.28

package/dist/scripts/agent-reach-tests.js

@@ -1,38 +1,46 @@
+/**
+ * agent-reach web 读取(readUrl 薄壳)测试:
+ *  readUrl = URL 校验 + 委托上游 WebChannel.read(反射桥) + Title 提取,自身无网络实现。
+ *  上游真读已在 §15 wrapper 测试覆盖;本套只测薄壳行为:
+ *  1. 非法 URL(不带 http) → 拒绝,不抛错,降级返回(离线确定性)
+ *  2. 1ms 超时 → 桥被杀,降级 error(离线确定性)
+ *  3. live 读 example.com → 成功时断言 Title/证据链;网络边界允许降级(不抛错)
+ *
+ * 运行: cd ts && npx tsx scripts/agent-reach-tests.ts
+ */
 import assert from 'node:assert/strict';
 import { readUrl } from '../capabilities/agent-reach.js';
+// 1. 非法 URL(不带 scheme)
 {
-    const r = await readUrl({
-        url: 'example.com'
-    });
+    const r = await readUrl({ url: 'example.com' });
     assert.equal(r.ok, false);
     assert.equal(r.via, 'r.jina.ai-error');
     assert.ok(r.evidence.includes('error'), 'evidence 带 error');
     console.log('1. 非法 URL 拒绝 OK');
-}{
-    const r = await readUrl({
-        url: 'https://example.com',
-        timeoutMs: 1
-    });
+}
+// 2. 超时(1ms 杀掉反射桥进程)
+{
+    const r = await readUrl({ url: 'https://example.com', timeoutMs: 1 });
     assert.equal(r.ok, false);
     assert.equal(r.via, 'r.jina.ai-error');
     assert.ok(r.latencyMs >= 0, '永不抛错');
     console.log('2. 超时降级 OK');
-}{
-    const r = await readUrl({
-        url: 'https://example.com',
-        timeoutMs: 30_000
-    });
+}
+// 3. live 读 example.com(上游 Jina Reader;网络边界允许降级)
+{
+    const r = await readUrl({ url: 'https://example.com', timeoutMs: 30_000 });
     if (r.ok) {
         assert.ok(r.evidence.includes('[agent-reach:web.read@'), '证据链');
         assert.match(r.evidence, /\[agent-reach:web\.read@2\d{3}-\d{2}-\d{2}T/, '证据链带 ISO 时间戳');
         assert.ok(typeof r.content === 'string' && r.content.length > 0, 'content 非空');
+        // live 内容会漂移(example.com 经 Jina 的 Title 曾从 Example Domain 变 Test Document),
+        // 断言结构(非空标题被提取)而非精确文案
         assert.ok(typeof r.title === 'string' && r.title.length > 0, `Title 提取,实际 ${r.title}`);
         console.log(`3. readUrl example.com → ok (title=${r.title}) OK`);
-    } else {
+    }
+    else {
         assert.equal(r.via, 'r.jina.ai-error');
         console.log(`3. readUrl example.com → 降级(${r.error?.slice(0, 60)})(网络边界,合法) OK`);
     }
-}console.log('\nAGENT-REACH TESTS: 3/3 OK(readUrl 薄壳;上游真读见 wrapper 套)');
-
-
-//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/agent-reach-tests.ts
+}
+console.log('\nAGENT-REACH TESTS: 3/3 OK(readUrl 薄壳;上游真读见 wrapper 套)');

package/dist/scripts/agent-reach-wrapper-tests.js

@@ -1,79 +1,79 @@
+/**
+ * agent-reach wrapper 测试(零渠道知识,全部走反射桥):
+ *  1. status: 真 agent-reach doctor 透传(via=agent-reach-cli)
+ *  2. web.read: 真读 example.com(上游 Jina Reader 后端)
+ *  3. v2ex.get_hot_topics: 上游 python 方法真调(网络边界允许降级)
+ *  4. xueqiu.get_stock_quote: 无 cookie → needs-setup 且 setup=上游 check() 原话
+ *  5. 未知渠道 → 自描述错误带回上游渠道清单
+ *  6. 未知方法 → 自描述错误带回上游方法签名清单
+ *  7. 永不抛错: 空 channel/method 降级
+ *
+ * 运行: cd ts && npx tsx scripts/agent-reach-wrapper-tests.ts
+ */
 import assert from 'node:assert/strict';
 import { reach, reachStatus } from '../capabilities/agent-reach.js';
+// 1. status(真 doctor 原样透传;agent-reach 未装时结构化 SKIP——真集成面设备绑定,
+//    与 §17 skills-contract「有凭证真校验,离线 SKIP」同构;CI 装了则全跑 7 断言)
 {
     const st = await reachStatus(90_000);
+    if (!st.ok) {
+        console.log(`SKIP: agent-reach doctor 未就绪(未安装/needs-setup),7 断言整体跳过 — via=${st.via} output=${String(st.output).slice(0, 120)}`);
+        process.exit(0);
+    }
     assert.equal(st.ok, true);
     assert.equal(st.via, 'agent-reach-cli');
     assert.ok(st.output.length > 50, 'doctor 输出非空(上游原样)');
     console.log(`1. status → doctor 透传 (${st.latencyMs}ms) OK`);
-}{
-    const r = await reach({
-        channel: 'web',
-        method: 'read',
-        args: [
-            'https://example.com'
-        ],
-        timeoutMs: 30_000
-    });
+}
+// 2. web.read(上游 WebChannel.read → Jina Reader)
+{
+    const r = await reach({ channel: 'web', method: 'read', args: ['https://example.com'], timeoutMs: 30_000 });
     assert.equal(r.verdict, 'found');
     assert.ok(r.evidence.includes('[agent-reach:web.read@'), '证据链 [agent-reach:web.read@ts]');
+    // live 内容会漂移(同 §13),断言非空 markdown 而非精确文案
     assert.ok(typeof r.data === 'string' && r.data.length > 200, 'content 非空 markdown');
     console.log(`2. web.read example.com → found (${r.latencyMs}ms) OK`);
-}{
-    const r = await reach({
-        channel: 'v2ex',
-        method: 'get_hot_topics',
-        timeoutMs: 30_000
-    });
+}
+// 3. v2ex.get_hot_topics(上游 python 方法;网络边界允许降级不抛错)
+{
+    const r = await reach({ channel: 'v2ex', method: 'get_hot_topics', timeoutMs: 30_000 });
     if (r.ok) {
         assert.ok(Array.isArray(r.data), 'hot topics 是数组');
         console.log(`3. v2ex.get_hot_topics → found (${r.data.length} topics) OK`);
-    } else {
-        assert.ok([
-            'error',
-            'needs-setup'
-        ].includes(r.verdict), '降级合法');
+    }
+    else {
+        assert.ok(['error', 'needs-setup'].includes(r.verdict), '降级合法');
         console.log(`3. v2ex.get_hot_topics → ${r.verdict}(网络边界,降级合法) OK`);
     }
-}{
-    const r = await reach({
-        channel: 'xueqiu',
-        method: 'get_stock_quote',
-        args: [
-            'SH600519'
-        ],
-        timeoutMs: 30_000
-    });
+}
+// 4. xueqiu.get_stock_quote(无 cookie → needs-setup 且 setup 是上游 check() 原话)
+{
+    const r = await reach({ channel: 'xueqiu', method: 'get_stock_quote', args: ['SH600519'], timeoutMs: 30_000 });
     assert.equal(r.verdict, 'needs-setup', `实际 verdict=${r.verdict} error=${r.error}`);
     assert.ok((r.setup ?? '').includes('configure'), 'setup 透传上游 configure 指引(不转述)');
     console.log('4. xueqiu.get_stock_quote → needs-setup(上游原话指引) OK');
-}{
-    const r = await reach({
-        channel: 'nosuch',
-        method: 'foo'
-    });
+}
+// 5. 未知渠道 → 自描述,带回上游渠道清单
+{
+    const r = await reach({ channel: 'nosuch', method: 'foo' });
     assert.equal(r.ok, false);
-    const channels = r.inventory?.channels ?? {};
+    const channels = (r.inventory?.channels ?? {});
     assert.ok(channels.web && channels.xueqiu && channels['exa_search'], 'inventory 带回上游注册表(含 exa_search 真名)');
     console.log(`5. 未知渠道 → 自描述清单(${Object.keys(channels).length} 渠道) OK`);
-}{
-    const r = await reach({
-        channel: 'web',
-        method: 'nosuch'
-    });
+}
+// 6. 未知方法 → 自描述,带回上游方法签名清单
+{
+    const r = await reach({ channel: 'web', method: 'nosuch' });
     assert.equal(r.ok, false);
-    const methods = r.inventory?.methods ?? {};
+    const methods = (r.inventory?.methods ?? {});
     assert.ok(methods.read, 'inventory.methods 带 read 签名');
     console.log(`6. 未知方法 → 自描述清单(${Object.keys(methods).length} 方法) OK`);
-}{
-    const r = await reach({
-        channel: '',
-        method: ''
-    });
+}
+// 7. 永不抛错: 空 channel/method
+{
+    const r = await reach({ channel: '', method: '' });
     assert.equal(r.ok, false);
     assert.equal(r.verdict, 'error');
     console.log('7. 空 channel/method 降级 OK');
-}console.log('\nAGENT-REACH WRAPPER TESTS: 7/7 OK(反射桥 + doctor 透传 + 自描述错误)');
-
-
-//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/agent-reach-wrapper-tests.ts
+}
+console.log('\nAGENT-REACH WRAPPER TESTS: 7/7 OK(反射桥 + doctor 透传 + 自描述错误)');

package/dist/scripts/anything-path-measure-tests.js

@@ -0,0 +1,133 @@
+/**
+ * Offline tests for the Anything-path measurement probe (issue #276 / #345 evidence probe).
+ *
+ * Run: cd ts && npx tsx scripts/anything-path-measure-tests.ts
+ *
+ * Fully offline: the real hbcli runner is never used; a scripted fake runner stands in. The opt-in
+ * claim is executed, not asserted: with the environment flag missing, the fake runner must be
+ * called exactly zero times.
+ */
+import assert from 'node:assert/strict';
+import { CONCURRENCY, OPT_IN_ENV, fieldPresence, latencyStats, measure, measureIfOptedIn, percentile, scrub, } from './anything-path-measure.js';
+const tests = [];
+const test = (name, run) => tests.push({ name, run });
+const hotel = (extra = {}) => ({ type: 'hotel', hotel: { name: 'H', star: 4, address: 'a', ...extra } });
+const city = () => ({ type: 'city', region: { name: 'C', countryCode: 'CN', extra: '' } });
+/** A scripted runner: results come from a queue per call; also tracks max in-flight calls. */
+function scripted(script) {
+    let calls = 0;
+    let inFlight = 0;
+    let maxInFlight = 0;
+    const runner = async (args) => {
+        const index = calls++;
+        inFlight++;
+        maxInFlight = Math.max(maxInFlight, inFlight);
+        await new Promise((resolve) => setImmediate(resolve));
+        inFlight--;
+        return script(args, index);
+    };
+    return { runner, stats: () => ({ calls, maxInFlight }) };
+}
+test('opt-in gate: without the env flag nothing is spawned and nothing is measured', async () => {
+    const fake = scripted(() => ({ ok: true, ms: 1, candidates: [] }));
+    const result = await measureIfOptedIn({}, fake.runner);
+    assert.equal(result.state, 'waiting_external_evidence');
+    assert.equal(fake.stats().calls, 0, 'runner must not be called without opt-in');
+    const wrong = await measureIfOptedIn({ [OPT_IN_ENV]: 'true' }, fake.runner);
+    assert.equal(wrong.state, 'waiting_external_evidence', 'only the exact value 1 opts in');
+    assert.equal(fake.stats().calls, 0);
+});
+test('opt-in gate: GOTRY_UAT_READONLY=1 runs the whole measurement', async () => {
+    const fake = scripted(() => ({ ok: true, ms: 5, candidates: [city()] }));
+    const result = await measureIfOptedIn({ [OPT_IN_ENV]: '1' }, fake.runner);
+    assert.equal(result.state, 'measured');
+    assert.ok(fake.stats().calls > 0);
+});
+test('percentile: nearest-rank, empty sample is null, single sample is itself', () => {
+    assert.equal(percentile([], 50), null);
+    assert.equal(percentile([7], 95), 7);
+    const sample = Array.from({ length: 20 }, (_, i) => (i + 1) * 10);
+    assert.equal(percentile(sample, 50), 100);
+    assert.equal(percentile(sample, 95), 190);
+    assert.equal(percentile([30, 10, 20], 50), 20, 'input order must not matter');
+});
+test('latencyStats counts failures by reason and keeps their timings in the sample', () => {
+    const stats = latencyStats([
+        { ok: true, ms: 100, candidates: [] },
+        { ok: false, ms: 900, reason: 'exit_1', detail: '' },
+        { ok: false, ms: 50, reason: 'exit_1', detail: '' },
+        { ok: false, ms: 60_000, reason: 'timeout', detail: '' },
+    ]);
+    assert.equal(stats.calls, 4);
+    assert.equal(stats.errors, 3);
+    assert.deepEqual(stats.error_reasons, { exit_1: 2, timeout: 1 });
+    assert.equal(stats.max_ms, 60_000);
+});
+test('fieldPresence: empty strings, empty arrays and empty objects do not count as present', () => {
+    const presence = fieldPresence([
+        { name: 'a', rating: 4.5, photos: [], hours: {}, note: '' },
+        { name: 'b', rating: null },
+        undefined,
+    ]);
+    assert.equal(presence.n, 2, 'undefined entries are not objects');
+    assert.deepEqual(presence.fields, { hours: '0/2', name: '2/2', note: '0/2', photos: '0/2', rating: '1/2' });
+});
+test('scrub: credential-looking material is redacted and the text is bounded', () => {
+    const scrubbed = scrub('401 Unauthorized: Bearer abc.def.ghi ticket=ST:12345 token: zzz api_key=k123 password hunter2');
+    assert.ok(!/abc\.def|12345|zzz|k123|hunter2/.test(scrubbed), `secret material survived: ${scrubbed}`);
+    assert.ok(scrubbed.length <= 160);
+    assert.ok(scrub('x'.repeat(1000)).length <= 160);
+});
+test('measure: aggregates a scripted run (types, place emptiness, presence, failures) deterministically', async () => {
+    const keywords = ['a', 'b', 'c', 'd', 'e', 'f', 'g'];
+    let n = 0;
+    const fake = scripted((args) => {
+        n++;
+        const placeOnly = args.includes('place');
+        if (placeOnly)
+            return { ok: true, ms: 10, candidates: [] };
+        if (n === 2)
+            return { ok: false, ms: 40, reason: 'exit_1', detail: 'boom' };
+        return { ok: true, ms: 20 + n, candidates: [city(), hotel(), hotel({ rating: 4.2 })] };
+    });
+    const fixedClock = () => new Date('2026-10-04T00:00:00.000Z');
+    const result = await measure(fake.runner, keywords, fixedClock);
+    assert.equal(result.measured_at, '2026-10-04T00:00:00.000Z');
+    assert.equal(result.sequential_mixed.calls, 7);
+    assert.equal(result.sequential_mixed.errors, 1);
+    assert.deepEqual(result.sequential_mixed.error_reasons, { exit_1: 1 });
+    assert.equal(result.sequential_place_only.errors, 0);
+    assert.equal(result.place_only_total_candidates, 0);
+    assert.equal(result.keywords_with_zero_place_results, '7/7');
+    assert.equal(result.place_object_field_presence.n, 0);
+    assert.deepEqual(Object.keys(result.mixed_candidates_by_type).sort(), ['city', 'hotel']);
+    assert.equal(result.mixed_candidates_by_type['city'], 6, 'one of seven mixed calls failed');
+    assert.equal(result.hotel_object_field_presence.fields['rating'], '6/12', 'half of the 12 hotel candidates carry a rating');
+    assert.equal(result.concurrent_mixed.concurrency, CONCURRENCY);
+    assert.equal(result.concurrent_mixed.calls, 7);
+});
+test('measure: the burst phase never exceeds the declared concurrency', async () => {
+    const keywords = Array.from({ length: 23 }, (_, i) => `k${i}`);
+    const fake = scripted(() => ({ ok: true, ms: 1, candidates: [] }));
+    await measure(fake.runner, keywords);
+    assert.ok(fake.stats().maxInFlight <= CONCURRENCY, `in-flight ${fake.stats().maxInFlight} exceeded ${CONCURRENCY}`);
+    assert.ok(fake.stats().maxInFlight > 1, 'burst phase must actually run concurrently');
+    assert.equal(fake.stats().calls, keywords.length * 3, 'mixed + place-only + burst');
+});
+let failed = 0;
+for (const { name, run } of tests) {
+    try {
+        await run();
+        console.log(`  ok   ${name}`);
+    }
+    catch (error) {
+        failed++;
+        console.error(`  FAIL ${name}`);
+        console.error(error);
+    }
+}
+if (failed > 0) {
+    console.error(`${failed} anything-path-measure test(s) failed`);
+    process.exit(1);
+}
+console.log(`anything-path-measure tests: ${tests.length} passed, 0 failed (offline: real hbcli runner never used)`);

package/dist/scripts/anything-path-measure.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env tsx
+/**
+ * Read-only measurement of the external Anything path
+ * (hbcli -> hotel-be /api/search/anything), the evidence probe for two trigger trackers:
+ *   #276  does the external path show a material latency/reliability bottleneck at scale?
+ *   #345  what fields does Anything actually return for place-like queries (rating/photos/hours)?
+ *
+ * Discipline:
+ *   - Opt-in only: without GOTRY_UAT_READONLY=1 it exits 0 with `waiting_external_evidence` and spawns nothing
+ *     (CI-safe; same no-spend discipline as nightly-evidence.ts).
+ *   - Read-only `search anything` calls against the environment hbcli is already authenticated for
+ *     (flags fixed to `--json --env=uat`). It never reads, prints or persists credentials.
+ *   - Prints aggregates only (latency percentiles, error counts, candidate-type counts, field-presence
+ *     ratios). Raw responses are not persisted; failure details are scrubbed and truncated.
+ *   - This MEASURES the real path. It does not satisfy either tracker's trigger: both need real M4
+ *     usage evidence (and, for #345, founder approval of per-call billing).
+ */
+import { execFile } from 'node:child_process';
+import { pathToFileURL } from 'node:url';
+export const DEFAULT_KEYWORDS = [
+    'Dali', '大理', '洱海', 'Erhai', 'Lijiang', '丽江', 'Phuket', '普吉', 'Rawai', 'Krabi', '甲米',
+    'Shenzhen', '深圳', 'Hong Kong', '香港', 'Dubai', '迪拜', 'Kunming', '昆明', 'Bangkok', '曼谷',
+    'Tokyo', 'Paris', 'Hilton', 'Marriott', 'Old Town', 'Airport', 'Beach',
+];
+export const OPT_IN_ENV = 'GOTRY_UAT_READONLY';
+export const CALL_TIMEOUT_MS = 60_000;
+export const CONCURRENCY = 5;
+/** Redact credential-looking material and bound the length of anything we keep from a failed call. */
+export function scrub(text) {
+    return text
+        .replace(/(bearer|ticket|token|authorization|secret|api[-_ ]?key|password)\s*[:=]?\s*[^\s"',}]+/gi, '$1=<redacted>')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .slice(0, 160);
+}
+/** Nearest-rank percentile; null for an empty sample. */
+export function percentile(values, p) {
+    if (values.length === 0)
+        return null;
+    const sorted = [...values].sort((a, b) => a - b);
+    return sorted[Math.min(sorted.length - 1, Math.ceil((p / 100) * sorted.length) - 1)] ?? null;
+}
+export function latencyStats(results) {
+    const reasons = {};
+    for (const r of results)
+        if (!r.ok)
+            reasons[r.reason] = (reasons[r.reason] ?? 0) + 1;
+    const times = results.map((r) => r.ms);
+    return {
+        calls: results.length,
+        errors: results.filter((r) => !r.ok).length,
+        error_reasons: reasons,
+        p50_ms: percentile(times, 50),
+        p95_ms: percentile(times, 95),
+        max_ms: times.length ? Math.max(...times) : null,
+    };
+}
+function isPresent(value) {
+    if (value === null || value === undefined || value === '')
+        return false;
+    if (Array.isArray(value))
+        return value.length > 0;
+    if (typeof value === 'object')
+        return Object.keys(value).length > 0;
+    return true;
+}
+/** For each key seen on any object: how many of the n objects carry a non-empty value (`"52/55"`). */
+export function fieldPresence(objects) {
+    const present = {};
+    const real = objects.filter((o) => o !== undefined && o !== null);
+    for (const o of real)
+        for (const [k, v] of Object.entries(o))
+            present[k] = (present[k] ?? 0) + (isPresent(v) ? 1 : 0);
+    const fields = {};
+    for (const k of Object.keys(present).sort())
+        fields[k] = `${present[k]}/${real.length}`;
+    return { n: real.length, fields };
+}
+/** Real runner: one hbcli call, classified, bounded, scrubbed. Never throws. */
+export const hbcliRunner = (args) => new Promise((resolve) => {
+    const started = performance.now();
+    execFile('hbcli', ['--json', '--env=uat', 'search', 'anything', ...args], { timeout: CALL_TIMEOUT_MS, maxBuffer: 8 << 20 }, (error, stdout, stderr) => {
+        const ms = Math.round(performance.now() - started);
+        if (error) {
+            const killed = error.killed === true;
+            const code = error.code;
+            const reason = killed ? 'timeout' : typeof code === 'number' ? `exit_${code}` : 'spawn_error';
+            resolve({ ok: false, ms, reason, detail: scrub(String(stderr || stdout || error.message)) });
+            return;
+        }
+        try {
+            const parsed = JSON.parse(String(stdout));
+            resolve({ ok: true, ms, candidates: Array.isArray(parsed.candidates) ? parsed.candidates : [] });
+        }
+        catch {
+            resolve({ ok: false, ms, reason: 'non_json', detail: scrub(String(stdout)) });
+        }
+    });
+});
+async function sequential(run, keywords, extra) {
+    const out = [];
+    for (const kw of keywords)
+        out.push(await run([kw, ...extra]));
+    return out;
+}
+async function concurrent(run, keywords, width) {
+    const out = [];
+    for (let i = 0; i < keywords.length; i += width) {
+        out.push(...await Promise.all(keywords.slice(i, i + width).map((kw) => run([kw]))));
+    }
+    return out;
+}
+/** Pure given a runner and a clock: the whole measurement, no environment access. */
+export async function measure(run, keywords = DEFAULT_KEYWORDS, now = () => new Date()) {
+    const mixed = await sequential(run, keywords, []);
+    const placeOnly = await sequential(run, keywords, ['--content-type', 'place']);
+    const burst = await concurrent(run, keywords, CONCURRENCY);
+    const mixedCandidates = mixed.flatMap((r) => (r.ok ? r.candidates : []));
+    const placeCandidates = placeOnly.flatMap((r) => (r.ok ? r.candidates : []));
+    const byType = {};
+    for (const c of mixedCandidates)
+        byType[c.type ?? 'unknown'] = (byType[c.type ?? 'unknown'] ?? 0) + 1;
+    const zeroPlace = placeOnly.filter((r) => r.ok && r.candidates.length === 0).length;
+    return {
+        state: 'measured',
+        measured_at: now().toISOString(),
+        hbcli_json_flags: '--json --env=uat',
+        sequential_mixed: latencyStats(mixed),
+        sequential_place_only: latencyStats(placeOnly),
+        concurrent_mixed: { ...latencyStats(burst), concurrency: CONCURRENCY },
+        mixed_candidates_by_type: byType,
+        place_only_total_candidates: placeCandidates.length,
+        keywords_with_zero_place_results: `${zeroPlace}/${keywords.length}`,
+        hotel_object_field_presence: fieldPresence(mixedCandidates.filter((c) => c.type === 'hotel').map((c) => c.hotel)),
+        city_region_field_presence: fieldPresence(mixedCandidates.filter((c) => c.type === 'city').map((c) => c.region)),
+        place_object_field_presence: fieldPresence(placeCandidates.map((c) => c.place)),
+    };
+}
+/** The opt-in gate: nothing is spawned unless the environment explicitly asks for it. */
+export async function measureIfOptedIn(env, run) {
+    if (env[OPT_IN_ENV] !== '1') {
+        return { state: 'waiting_external_evidence', reason: `${OPT_IN_ENV}=1 not set; no hbcli process was spawned, nothing was measured` };
+    }
+    return measure(run);
+}
+if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    measureIfOptedIn(process.env, hbcliRunner).then((result) => {
+        console.log(JSON.stringify(result, null, 2));
+    });
+}