@danceiny/gotry 0.0.1-rc.14 → 0.0.1-rc.16

package/dist/scripts/onboarding-tests.js

@@ -0,0 +1,218 @@
+import assert from 'node:assert/strict';
+import { runOnboardingWizard, defaultExtensionDir, describeExtensionDir } from '../capabilities/session/wizard.js';
+import { startExtensionHealthWatch, withAutoRetryOnExtension, HEALTH_WATCH_INTERVAL_FLOOR_MS, HEALTH_WATCH_INTERVAL_CEIL_MS } from '../capabilities/session/health-watch.js';
+let passed = 0;
+function check(label, fn) {
+    return Promise.resolve().then(fn).then(()=>{
+        passed += 1;
+        console.log(`  ok - ${label}`);
+    });
+}
+function noopSpawn() {
+    const { EventEmitter } = require('node:events');
+    const child = new EventEmitter();
+    const stream = new EventEmitter();
+    child.stdin = stream;
+    child.stdout = null;
+    child.stderr = null;
+    child.unref = ()=>undefined;
+    return child;
+}
+function captureSpawn() {
+    const calls = [];
+    const spawn = (bin, args = [])=>{
+        calls.push({
+            bin,
+            args
+        });
+        return noopSpawn();
+    };
+    return {
+        spawn,
+        calls
+    };
+}
+async function asyncSleep(ms) {
+    if (ms <= 0) return;
+    await new Promise((resolve)=>setTimeout(resolve, ms));
+}
+console.log('ONBOARDING UX (§40)');
+await check('1. wizard --dry-run 零网络零浏览器,exit 0,5 步齐全', async ()=>{
+    const { spawn } = captureSpawn();
+    const result = await runOnboardingWizard({
+        dryRun: true,
+        forcePlatform: 'darwin',
+        spawn
+    });
+    assert.equal(result.ok, true, `wizard ok 应 true,实际 ${JSON.stringify(result.steps)}`);
+    assert.equal(result.steps.length, 5, `应有 5 步,实际 ${result.steps.length}`);
+    const expected = [
+        'ensure-extension-files',
+        'open-chrome-extensions',
+        'clipboard-extension-path',
+        'panel-guide',
+        'watch-extension-ready'
+    ];
+    for(let i = 0; i < expected.length; i++){
+        assert.equal(result.steps[i].step, expected[i]);
+        assert.equal(result.steps[i].status, 'skip', `dry-run 每步应为 skip,${result.steps[i].step} 实为 ${result.steps[i].status}`);
+    }
+    assert.equal(result.platform, 'darwin');
+});
+await check('2. health-watch 三时序:0ms / 中途 / 120s+1ms', async ()=>{
+    const w0 = startExtensionHealthWatch({
+        timeoutMs: 0,
+        intervalMs: 10
+    });
+    const o0 = await w0.waitReady();
+    assert.equal(o0.ready, false);
+    assert.equal(o0.reason, 'timeout');
+    let probeCalls = 0;
+    const wMid = startExtensionHealthWatch({
+        timeoutMs: 500,
+        intervalMs: 30,
+        probe: async ()=>{
+            probeCalls += 1;
+            return probeCalls >= 2;
+        }
+    });
+    const oMid = await wMid.waitReady();
+    assert.equal(oMid.ready, true, `中途 ready 实为 ${JSON.stringify(oMid)}`);
+    assert.ok(oMid.attempts >= 2);
+    const wTimeout = startExtensionHealthWatch({
+        timeoutMs: 60,
+        intervalMs: 20,
+        probe: async ()=>false
+    });
+    const oTimeout = await wTimeout.waitReady();
+    assert.equal(oTimeout.ready, false);
+    assert.equal(oTimeout.reason, 'timeout');
+});
+await check('3. 剪贴板 + GUI 面板跨平台降级', async ()=>{
+    const darwin = captureSpawn();
+    const rDarwin = await runOnboardingWizard({
+        dryRun: false,
+        forcePlatform: 'darwin',
+        extensionDir: '/tmp/gotry-test-ext',
+        spawn: darwin.spawn,
+        sourceDir: '/'
+    });
+    const darwinBins = darwin.calls.map((c)=>c.bin);
+    assert.ok(darwinBins.includes('open'), `darwin 应调 open(实调 ${darwinBins.join(',')})`);
+    assert.ok(darwinBins.includes('pbcopy'), 'darwin 应调 pbcopy');
+    assert.ok(darwinBins.includes('osascript'), 'darwin 应调 osascript');
+    const linux = captureSpawn();
+    await runOnboardingWizard({
+        dryRun: false,
+        forcePlatform: 'linux',
+        extensionDir: '/tmp/gotry-test-ext',
+        spawn: linux.spawn,
+        sourceDir: '/'
+    });
+    const linuxBins = linux.calls.map((c)=>c.bin);
+    assert.ok(linuxBins.includes('xdg-open'), `linux 应调 xdg-open(实调 ${linuxBins.join(',')})`);
+    assert.ok(linuxBins.includes('xclip'), 'linux 应调 xclip');
+    assert.ok(linuxBins.includes('zenity'), 'linux 应调 zenity');
+    const headless = captureSpawn();
+    const rHeadless = await runOnboardingWizard({
+        dryRun: true,
+        forcePlatform: 'headless',
+        extensionDir: '/tmp/gotry-test-ext',
+        spawn: headless.spawn
+    });
+    assert.equal(headless.calls.length, 0, `headless 不应 spawn 任何命令(实调 ${headless.calls.length})`);
+    assert.equal(rHeadless.platform, 'headless');
+});
+await check('4. retry-after-watch:needs-extension → watch ready → 自动重放同 query_id', async ()=>{
+    let fetchCalls = 0;
+    const queryId = 'sf-01';
+    const fetch = async ()=>{
+        fetchCalls += 1;
+        return {
+            query_id: queryId,
+            verdict: 'needs-extension',
+            needsExt: fetchCalls === 1
+        };
+    };
+    const first = await fetch();
+    assert.equal(first.verdict, 'needs-extension');
+    let probeCount = 0;
+    const watch = startExtensionHealthWatch({
+        timeoutMs: 1_000,
+        intervalMs: 20,
+        probe: async ()=>{
+            probeCount += 1;
+            return probeCount >= 2;
+        }
+    });
+    const outcome = await watch.waitReady();
+    assert.equal(outcome.ready, true);
+    const retry = await fetch();
+    assert.equal(retry.query_id, queryId, '同 query_id 必须保持');
+    assert.equal(fetchCalls, 2, `应调用 fetch 两次(首次 + 重放),实 ${fetchCalls}`);
+});
+await check('5. wizard 无 GUI 走终端降级', async ()=>{
+    const headless = captureSpawn();
+    const result = await runOnboardingWizard({
+        dryRun: true,
+        forcePlatform: 'headless',
+        extensionDir: '/tmp/gotry-test-ext',
+        spawn: headless.spawn
+    });
+    const clip = result.steps.find((s)=>s.step === 'clipboard-extension-path');
+    const panel = result.steps.find((s)=>s.step === 'panel-guide');
+    const watch = result.steps.find((s)=>s.step === 'watch-extension-ready');
+    assert.equal(clip?.status, 'skip', 'headless 剪贴板应 skip');
+    assert.equal(panel?.status, 'skip', 'headless 面板应 skip(终端降级)');
+    assert.equal(watch?.status, 'skip', 'dry-run watch 应 skip');
+    assert.equal(headless.calls.length, 0, `headless 不应调任何 spawn(实调 ${headless.calls.length})`);
+});
+await check('6. withAutoRetryOnExtension 端到端:首次 needs-ext → 自动重放', async ()=>{
+    let callCount = 0;
+    let ready = false;
+    setTimeout(()=>{
+        ready = true;
+    }, 30);
+    const args = {
+        fetch: async ()=>{
+            callCount += 1;
+            return callCount === 1 ? {
+                needsExt: true
+            } : {
+                needsExt: false,
+                hit: true
+            };
+        },
+        isExtensionNeeded: (r)=>r.needsExt === true,
+        watch: {
+            timeoutMs: 1_000,
+            intervalMs: 20,
+            probe: async ()=>ready
+        }
+    };
+    const out = await withAutoRetryOnExtension(args);
+    assert.equal(out.retried, true, `应触发重放,实 retried=${out.retried}`);
+    assert.equal(out.attempts, 2);
+    assert.equal(out.result.needsExt, false);
+    assert.equal(out.result.hit, true);
+    assert.equal(callCount, 2, `withAutoRetry 应调 2 次 fetch,实 ${callCount}`);
+});
+await check('7. health-watch interval 边界常量与 watch 契约对齐', ()=>{
+    assert.ok(HEALTH_WATCH_INTERVAL_FLOOR_MS >= 1_000, '下界不应让 watch 风暴');
+    assert.ok(HEALTH_WATCH_INTERVAL_CEIL_MS <= 44_000, '上界应 < EXTENSION_CONNECTED_WINDOW_MS');
+});
+await check('8. defaultExtensionDir = ~/.gotry/extension(契约对齐 bootstrap 节)', ()=>{
+    const dir = defaultExtensionDir();
+    assert.match(dir, /\.gotry[\\/]extension$/, `扩展目录形态应是 ~/.gotry/extension,实 ${dir}`);
+});
+await check('9. describeExtensionDir:不存在的目录不抛错,返回 exists:false', ()=>{
+    const desc = describeExtensionDir('/nonexistent/zzz');
+    assert.equal(desc.exists, false);
+    assert.equal(desc.fileCount, 0);
+    assert.equal(desc.hasManifest, false);
+});
+await asyncSleep(0);
+console.log(`ONBOARDING UX (§40): ${passed} pass`);
+
+
+//# sourceURL=/Users/bytedance/work/gotry-publish/ts/scripts/onboarding-tests.ts

package/dist/scripts/opensky-check.js

@@ -17,4 +17,4 @@ const target = process.argv[2] ?? 'EK329';
 console.log(await checkArrival(target, process.argv[3] ?? null));
 
 
-//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/opensky-check.ts
+//# sourceURL=/Users/bytedance/work/gotry-publish/ts/scripts/opensky-check.ts

package/dist/scripts/opensky-tests.js

@@ -49,4 +49,4 @@ console.log('3. timeout → unavailable OK');
 console.log('\nOPEN-SKY TESTS: 3/3 OK(免费匿名 OpenSky API)');
 
 
-//# sourceURL=/Users/bytedance/work/gotry/ts/scripts/opensky-tests.ts
+//# sourceURL=/Users/bytedance/work/gotry-publish/ts/scripts/opensky-tests.ts

package/dist/scripts/price-drift-tests.js

@@ -0,0 +1,441 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { runPriceDriftWatch, parseOpenaiHtml } from './price-drift-watch.js';
+let passed = 0;
+function ok(label) {
+    passed += 1;
+    console.log(`  ok ${label}`);
+}
+function tmpRoot() {
+    return mkdtempSync(join(tmpdir(), 'drift-'));
+}
+function makeBaseline(rows, asOf = '2026-08-30T00:00:00.000Z') {
+    return JSON.stringify({
+        schema_version: 'gotry_llm_price_baseline_v1',
+        as_of: asOf,
+        source_url: 'mock://test',
+        rows
+    });
+}
+function makeMockProvider(id, baselinePath, _fetchReturn) {
+    const parser = (html)=>{
+        const rows = [];
+        for (const seg of html.split(';')){
+            const [model, nums] = seg.split(':');
+            if (!model || !nums) continue;
+            const [miss, hit, out] = nums.split(',').map(Number);
+            if (!Number.isFinite(miss) || !Number.isFinite(out)) continue;
+            rows.push({
+                model: model.trim(),
+                input_cache_miss_usd_per_1m: miss,
+                input_cache_hit_usd_per_1m: Number.isFinite(hit) ? hit : null,
+                output_usd_per_1m: out
+            });
+        }
+        return rows;
+    };
+    return [
+        {
+            id,
+            source_url: `mock://${id}`,
+            baseline_path: baselinePath,
+            parse: parser
+        }
+    ];
+}
+function fetcherFromMap(map) {
+    return async (url)=>{
+        const v = map[url];
+        if (v instanceof Error) throw v;
+        if (typeof v === 'string') return v;
+        throw new Error(`no mock for ${url}`);
+    };
+}
+async function testOfflineNoBaseline() {
+    const root = tmpRoot();
+    try {
+        const report = await runPriceDriftWatch({
+            mode: 'offline',
+            observedAt: ()=>new Date('2026-08-30T12:00:00Z'),
+            providers: makeMockProvider('mockprov', join(root, 'no-such-file.json'), '')
+        });
+        assert.equal(report.schema_version, 'gotry_llm_price_drift_v1');
+        assert.equal(report.providers['mockprov'].status, 'skipped_no_baseline');
+        ok('offline 无 baseline → skipped_no_baseline');
+    } finally{
+        rmSync(root, {
+            recursive: true,
+            force: true
+        });
+    }
+}
+async function testOfflineWithBaseline() {
+    const root = tmpRoot();
+    try {
+        const bp = join(root, 'b.json');
+        writeFileSync(bp, makeBaseline([
+            {
+                model: 'm1',
+                input_cache_miss_usd_per_1m: 1.0,
+                input_cache_hit_usd_per_1m: 0.1,
+                output_usd_per_1m: 3.0
+            }
+        ]));
+        const report = await runPriceDriftWatch({
+            mode: 'offline',
+            observedAt: ()=>new Date('2026-08-30T12:00:00Z'),
+            providers: makeMockProvider('mockprov', bp, '')
+        });
+        assert.equal(report.providers['mockprov'].status, 'unchanged');
+        assert.match(report.providers['mockprov'].reason ?? '', /--fetch/, 'offline reason 应提示 --fetch');
+        ok('offline 有 baseline → unchanged + reason 提示 --fetch');
+    } finally{
+        rmSync(root, {
+            recursive: true,
+            force: true
+        });
+    }
+}
+async function testFetchFailure() {
+    const root = tmpRoot();
+    try {
+        const bp = join(root, 'b.json');
+        writeFileSync(bp, makeBaseline([
+            {
+                model: 'm1',
+                input_cache_miss_usd_per_1m: 1.0,
+                input_cache_hit_usd_per_1m: 0.1,
+                output_usd_per_1m: 3.0
+            }
+        ]));
+        const report = await runPriceDriftWatch({
+            mode: 'fetch',
+            observedAt: ()=>new Date('2026-08-30T12:00:00Z'),
+            providers: makeMockProvider('mockprov', bp, ''),
+            fetcher: fetcherFromMap({
+                'mock://mockprov': new Error('ECONNREFUSED')
+            })
+        });
+        assert.equal(report.providers['mockprov'].status, 'skipped_no_network');
+        assert.match(report.providers['mockprov'].reason ?? '', /ECONNREFUSED/);
+        ok('fetch 失败 → skipped_no_network');
+    } finally{
+        rmSync(root, {
+            recursive: true,
+            force: true
+        });
+    }
+}
+async function testFetchFirstTimeWritesBaseline() {
+    const root = tmpRoot();
+    try {
+        const bp = join(root, 'b.json');
+        const report = await runPriceDriftWatch({
+            mode: 'fetch',
+            observedAt: ()=>new Date('2026-08-30T12:00:00Z'),
+            providers: makeMockProvider('mockprov', bp, ''),
+            fetcher: fetcherFromMap({
+                'mock://mockprov': 'm1:1.0,0.1,3.0;m2:2.0,0.2,5.0'
+            })
+        });
+        assert.equal(report.providers['mockprov'].status, 'fetched_no_table_entry');
+        const { existsSync, readFileSync } = await import('node:fs');
+        assert.ok(existsSync(bp), 'baseline fixture 必须被写');
+        const written = JSON.parse(readFileSync(bp, 'utf8'));
+        assert.equal(written['schema_version'], 'gotry_llm_price_baseline_v1');
+        assert.ok(Array.isArray(written['rows']));
+        assert.equal(written['rows'].length, 2);
+        ok('fetch 首次 → fetched_no_table_entry + 写 fixture');
+    } finally{
+        rmSync(root, {
+            recursive: true,
+            force: true
+        });
+    }
+}
+async function testFetchUnchanged() {
+    const root = tmpRoot();
+    try {
+        const bp = join(root, 'b.json');
+        writeFileSync(bp, makeBaseline([
+            {
+                model: 'm1',
+                input_cache_miss_usd_per_1m: 1.0,
+                input_cache_hit_usd_per_1m: 0.1,
+                output_usd_per_1m: 3.0
+            }
+        ]));
+        const report = await runPriceDriftWatch({
+            mode: 'fetch',
+            observedAt: ()=>new Date('2026-08-30T12:00:00Z'),
+            providers: makeMockProvider('mockprov', bp, ''),
+            fetcher: fetcherFromMap({
+                'mock://mockprov': 'm1:1.0,0.1,3.0'
+            })
+        });
+        assert.equal(report.providers['mockprov'].status, 'unchanged');
+        ok('fetch 模式:baseline + current 同 → unchanged');
+    } finally{
+        rmSync(root, {
+            recursive: true,
+            force: true
+        });
+    }
+}
+async function testFetchDrift() {
+    const root = tmpRoot();
+    try {
+        const bp = join(root, 'b.json');
+        writeFileSync(bp, makeBaseline([
+            {
+                model: 'm-keep',
+                input_cache_miss_usd_per_1m: 1.0,
+                input_cache_hit_usd_per_1m: 0.1,
+                output_usd_per_1m: 3.0
+            },
+            {
+                model: 'm-up',
+                input_cache_miss_usd_per_1m: 1.0,
+                input_cache_hit_usd_per_1m: 0.1,
+                output_usd_per_1m: 3.0
+            },
+            {
+                model: 'm-down',
+                input_cache_miss_usd_per_1m: 1.0,
+                input_cache_hit_usd_per_1m: 0.1,
+                output_usd_per_1m: 3.0
+            },
+            {
+                model: 'm-removed',
+                input_cache_miss_usd_per_1m: 1.0,
+                input_cache_hit_usd_per_1m: 0.1,
+                output_usd_per_1m: 3.0
+            }
+        ]));
+        const report = await runPriceDriftWatch({
+            mode: 'fetch',
+            observedAt: ()=>new Date('2026-08-30T12:00:00Z'),
+            providers: makeMockProvider('mockprov', bp, ''),
+            fetcher: fetcherFromMap({
+                'mock://mockprov': [
+                    'm-keep:1.0,0.1,3.0',
+                    'm-up:1.5,0.1,3.0',
+                    'm-down:0.8,0.1,3.0',
+                    'm-new:2.0,0.2,4.0'
+                ].join(';')
+            })
+        });
+        const r = report.providers['mockprov'];
+        assert.equal(r.status, 'drift');
+        const drift = r.drift ?? [];
+        const fields = drift.map((d)=>`${d.model}|${d.field}|${d.direction}`).sort();
+        assert.deepEqual(fields, [
+            'm-down|input_cache_miss_usd_per_1m|down',
+            'm-new|input_cache_miss_usd_per_1m|new',
+            'm-removed|input_cache_miss_usd_per_1m|removed',
+            'm-up|input_cache_miss_usd_per_1m|up'
+        ], 'drift 字段方向必须逐项正确');
+        ok('fetch drift:up/down/new/removed 四向全检');
+    } finally{
+        rmSync(root, {
+            recursive: true,
+            force: true
+        });
+    }
+}
+async function testPrParagraph() {
+    const root = tmpRoot();
+    try {
+        const bp = join(root, 'b.json');
+        writeFileSync(bp, makeBaseline([
+            {
+                model: 'deepseek-v4-flash',
+                input_cache_miss_usd_per_1m: 1.32,
+                input_cache_hit_usd_per_1m: 0.014,
+                output_usd_per_1m: 3.0
+            }
+        ]));
+        const report = await runPriceDriftWatch({
+            mode: 'fetch',
+            observedAt: ()=>new Date('2026-08-30T12:00:00Z'),
+            providers: makeMockProvider('mockprov', bp, ''),
+            fetcher: fetcherFromMap({
+                'mock://mockprov': 'deepseek-v4-flash:1.32,0.014,3.0'
+            })
+        });
+        assert.equal(report.providers['mockprov'].status, 'unchanged');
+        assert.match(report.suggested_pr_paragraph, /价格漂移监测/);
+        assert.match(report.suggested_pr_paragraph, /mockprov/);
+        assert.match(report.suggested_pr_paragraph, /人工 PR/);
+        ok('PR 段落含监测标题 + provider 变动 + 纪律注脚');
+    } finally{
+        rmSync(root, {
+            recursive: true,
+            force: true
+        });
+    }
+}
+async function testBadBaseline() {
+    const root = tmpRoot();
+    try {
+        const bp = join(root, 'b.json');
+        writeFileSync(bp, JSON.stringify({
+            schema_version: 'gotry_llm_price_baseline_v99',
+            rows: []
+        }));
+        const report = await runPriceDriftWatch({
+            mode: 'offline',
+            observedAt: ()=>new Date('2026-08-30T12:00:00Z'),
+            providers: makeMockProvider('mockprov', bp, '')
+        });
+        assert.equal(report.providers['mockprov'].status, 'skipped_no_baseline', '坏 baseline schema_version 视为不存在,offline 标 SKIP');
+        ok('坏 baseline schema_version → offline 视为不存在(SKIP)');
+    } finally{
+        rmSync(root, {
+            recursive: true,
+            force: true
+        });
+    }
+}
+await testOfflineNoBaseline();
+await testOfflineWithBaseline();
+await testFetchFailure();
+await testFetchFirstTimeWritesBaseline();
+await testFetchUnchanged();
+await testFetchDrift();
+await testPrParagraph();
+await testBadBaseline();
+async function testSnapshotNextDataParser() {
+    const root = tmpRoot();
+    try {
+        const bp = join(root, 'b.json');
+        const sp = join(root, 'snapshot.html');
+        writeFileSync(bp, makeBaseline([
+            {
+                model: 'gpt-4o',
+                input_cache_miss_usd_per_1m: 2.5,
+                input_cache_hit_usd_per_1m: 1.25,
+                output_usd_per_1m: 10.0
+            }
+        ]));
+        const html = `<html><script id="__NEXT_DATA__" type="application/json">${JSON.stringify({
+            props: {
+                pageProps: {
+                    models: [
+                        {
+                            name: 'gpt-4o',
+                            input_cost_per_token: 0.0000025,
+                            output_cost_per_token: 0.00001,
+                            cached_input_cost_per_token: 0.00000125
+                        }
+                    ]
+                }
+            }
+        })}</script></html>`;
+        writeFileSync(sp, html);
+        const report = await runPriceDriftWatch({
+            mode: 'offline',
+            observedAt: ()=>new Date('2026-08-30T12:00:00Z'),
+            providers: [
+                {
+                    id: 'mockprov',
+                    source_url: 'mock://mockprov',
+                    baseline_path: bp,
+                    snapshot_path: sp,
+                    parse: parseOpenaiHtml
+                }
+            ]
+        });
+        assert.equal(report.providers['mockprov'].status, 'unchanged', 'snapshot 与 baseline 同价 → unchanged(offline)');
+        ok('snapshot 路径:__NEXT_DATA__ 内嵌 JSON dump 解析成功 + 与 baseline 同 → unchanged');
+    } finally{
+        rmSync(root, {
+            recursive: true,
+            force: true
+        });
+    }
+}
+async function testSnapshotFallbackDrift() {
+    const root = tmpRoot();
+    try {
+        const bp = join(root, 'b.json');
+        const sp = join(root, 'snapshot.html');
+        writeFileSync(bp, makeBaseline([
+            {
+                model: 'gpt-4o',
+                input_cache_miss_usd_per_1m: 2.5,
+                input_cache_hit_usd_per_1m: 1.25,
+                output_usd_per_1m: 10.0
+            }
+        ]));
+        const html = '<html><body><p>gpt-4o … $5.00 / 1M input … $20.00 / 1M output</p></body></html>';
+        writeFileSync(sp, html);
+        const report = await runPriceDriftWatch({
+            mode: 'offline',
+            observedAt: ()=>new Date('2026-08-30T12:00:00Z'),
+            providers: [
+                {
+                    id: 'mockprov',
+                    source_url: 'mock://mockprov',
+                    baseline_path: bp,
+                    snapshot_path: sp,
+                    parse: parseOpenaiHtml
+                }
+            ]
+        });
+        const r = report.providers['mockprov'];
+        assert.equal(r.status, 'drift', 'snapshot fallback 解析 + baseline 不一致 → drift');
+        const drift = r.drift ?? [];
+        assert.ok(drift.some((d)=>d.field === 'input_cache_miss_usd_per_1m' && d.from === 2.5 && d.to === 5.0 && d.direction === 'up'), 'miss 字段 up drift');
+        assert.ok(drift.some((d)=>d.field === 'output_usd_per_1m' && d.from === 10.0 && d.to === 20.0 && d.direction === 'up'), 'output 字段 up drift');
+        ok('snapshot fallback:段落文字解析 + 与 baseline 不同 → drift(含 up/down/new/removed)');
+    } finally{
+        rmSync(root, {
+            recursive: true,
+            force: true
+        });
+    }
+}
+async function testSnapshotMissing() {
+    const root = tmpRoot();
+    try {
+        const bp = join(root, 'b.json');
+        writeFileSync(bp, makeBaseline([
+            {
+                model: 'gpt-4o',
+                input_cache_miss_usd_per_1m: 2.5,
+                input_cache_hit_usd_per_1m: 1.25,
+                output_usd_per_1m: 10.0
+            }
+        ]));
+        const report = await runPriceDriftWatch({
+            mode: 'offline',
+            observedAt: ()=>new Date('2026-08-30T12:00:00Z'),
+            providers: [
+                {
+                    id: 'mockprov',
+                    source_url: 'mock://mockprov',
+                    baseline_path: bp,
+                    snapshot_path: join(root, 'no-such-snapshot.html'),
+                    parse: parseOpenaiHtml
+                }
+            ]
+        });
+        assert.equal(report.providers['mockprov'].status, 'skipped_no_snapshot', 'snapshot 缺失 → SKIP');
+        ok('snapshot 缺失 → skipped_no_snapshot(offline)');
+    } finally{
+        rmSync(root, {
+            recursive: true,
+            force: true
+        });
+    }
+}
+await testSnapshotNextDataParser();
+await testSnapshotFallbackDrift();
+await testSnapshotMissing();
+console.log(`price-drift-watch tests: ${passed} 组断言全绿(offline,fetch 模式手动/CI 心跳)`);
+
+
+//# sourceURL=/Users/bytedance/work/gotry-publish/ts/scripts/price-drift-tests.ts