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

package/dist/capabilities/effect.js

@@ -0,0 +1,293 @@
+import { CircuitBreaker, withRetry } from './resilience.js';
+import { flyaiSearch } from './flyai.js';
+import { checkAvail, hotelRates, searchHotels } from './hbcli.js';
+import { sessionFlightSearch } from './session-search.js';
+import { geocodePlace, getClimate, getForecast } from './weather.js';
+import { verifyFlight } from './opensky.js';
+const DEFAULT_HANDLERS = {
+    FLYAI_SEARCH: (p)=>flyaiSearch(p),
+    HBCLI_HOTEL_SEARCH: (p)=>searchHotels({
+            destination: p.destination,
+            checkIn: p.checkIn,
+            checkOut: p.checkOut,
+            adults: p.adults
+        }, {
+            hbcliBin: p.hbcliBin,
+            timeoutMs: p.timeoutMs,
+            fallbackPath: p.fallbackPath
+        }),
+    HBCLI_HOTEL_RATES: (p)=>hotelRates({
+            hotelId: p.hotelId,
+            checkIn: p.checkIn,
+            checkOut: p.checkOut,
+            adults: p.adults,
+            countryCode: p.countryCode,
+            nationalityCode: p.nationalityCode,
+            residencyCode: p.residencyCode
+        }, {
+            hbcliBin: p.hbcliBin,
+            timeoutMs: p.timeoutMs
+        }),
+    HBCLI_CHECK_AVAIL: (p)=>checkAvail({
+            ratePkgId: p.ratePkgId
+        }, {
+            hbcliBin: p.hbcliBin,
+            timeoutMs: p.timeoutMs
+        }),
+    SESSION_FLIGHT_SEARCH: (p)=>sessionFlightSearch(p),
+    WEATHER_GEOCODE: (p)=>geocodePlace(p.name, {
+            count: p.count,
+            timeoutMs: p.timeoutMs
+        }),
+    WEATHER_FORECAST: (p)=>getForecast({
+            latitude: p.latitude,
+            longitude: p.longitude
+        }, {
+            days: p.days,
+            timeoutMs: p.timeoutMs
+        }),
+    WEATHER_CLIMATE: (p)=>getClimate({
+            latitude: p.latitude,
+            longitude: p.longitude
+        }, p.month, {
+            timeoutMs: p.timeoutMs
+        }),
+    OPENSKY_FLIGHT_VERIFY: (p)=>verifyFlight(p)
+};
+const defaultIsFailure = (r)=>r?.ok === false;
+const flyaiTransient = (msg)=>msg.length > 0 && !/Sentinel/i.test(msg) && /timeout|timed out|ECONNRESET|ECONNREFUSED|ETIMEDOUT|socket|HTTP 5/i.test(msg);
+const API_RETRY = {
+    maxAttempts: 2,
+    baseDelayMs: 400,
+    maxDelayMs: 1_600
+};
+const API_BREAKER = {
+    failureThreshold: 3,
+    openMs: 30_000
+};
+const SPECS = {
+    FLYAI_SEARCH: {
+        channel: 'cli',
+        retry: {
+            maxAttempts: 2,
+            baseDelayMs: 500,
+            maxDelayMs: 2_000
+        },
+        breaker: {
+            failureThreshold: 3,
+            openMs: 60_000
+        },
+        isRetryable: (_r, e)=>{
+            const msg = e != null ? String(e.message ?? e) : String((_r ?? {}).error ?? '');
+            return flyaiTransient(msg);
+        },
+        isFailure: defaultIsFailure
+    },
+    HBCLI_HOTEL_SEARCH: {
+        channel: 'cli',
+        retry: null,
+        breaker: {
+            failureThreshold: 3,
+            openMs: 60_000
+        },
+        isFailure: (r)=>r.via === 'hbcli-error'
+    },
+    HBCLI_HOTEL_RATES: {
+        channel: 'cli',
+        retry: null,
+        breaker: {
+            failureThreshold: 3,
+            openMs: 60_000
+        },
+        isFailure: (r)=>r.via === 'hbcli-error'
+    },
+    HBCLI_CHECK_AVAIL: {
+        channel: 'cli',
+        retry: null,
+        breaker: {
+            failureThreshold: 3,
+            openMs: 60_000
+        },
+        isFailure: (r)=>r.via === 'hbcli-error'
+    },
+    SESSION_FLIGHT_SEARCH: {
+        channel: 'browser',
+        retry: null,
+        breaker: null,
+        isFailure: defaultIsFailure
+    },
+    WEATHER_GEOCODE: {
+        channel: 'api',
+        retry: API_RETRY,
+        breaker: API_BREAKER,
+        isFailure: defaultIsFailure
+    },
+    WEATHER_FORECAST: {
+        channel: 'api',
+        retry: API_RETRY,
+        breaker: API_BREAKER,
+        isFailure: defaultIsFailure
+    },
+    WEATHER_CLIMATE: {
+        channel: 'api',
+        retry: API_RETRY,
+        breaker: API_BREAKER,
+        isFailure: defaultIsFailure
+    },
+    OPENSKY_FLIGHT_VERIFY: {
+        channel: 'api',
+        retry: API_RETRY,
+        breaker: API_BREAKER,
+        isRetryable: (_r, e)=>e != null || (_r ?? {}).verdict === 'unavailable',
+        isFailure: (r)=>r.via === 'opensky-error'
+    }
+};
+export function declinedObservation(effect, trace) {
+    return {
+        ok: false,
+        verdict: 'error',
+        summary: trace.declined === 'circuit-open' ? `${effect} 通道被断路器开启保护(连续失败达到阈值,冷却中)——不要立即重试,换其他工具或稍后再试;原因见 trace 证据链` : `${effect} 未登记效应(effect_interpreter.v1 注册表外,生产解译器拒绝)`,
+        evidence: trace.evidence.join(';')
+    };
+}
+const defaultBreakers = new Map();
+const defaultSleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
+export function __resetEffectBreakersForTest() {
+    defaultBreakers.clear();
+}
+export function makeProductionInterpreter(opts = {}) {
+    const breakers = opts.breakers ?? defaultBreakers;
+    const sleep = opts.sleep ?? defaultSleep;
+    return async (fx)=>{
+        const ts = new Date().toISOString();
+        const name = fx.effect;
+        const spec = SPECS[name];
+        const handler = opts.handlers?.[fx.effect] ?? DEFAULT_HANDLERS[name];
+        if (!spec || !handler) {
+            return {
+                result: null,
+                trace: {
+                    effect: fx.effect,
+                    channel: 'api',
+                    attempts: 0,
+                    backoffMs: 0,
+                    breaker: 'off',
+                    declined: 'unknown-effect',
+                    evidence: [
+                        `[效应:${fx.effect}@${ts}] unknown effect`
+                    ]
+                }
+            };
+        }
+        const br = (()=>{
+            if (!spec.breaker) return null;
+            const existing = breakers.get(fx.effect);
+            if (existing) return existing;
+            const created = new CircuitBreaker({
+                ...spec.breaker,
+                ...opts.now ? {
+                    now: opts.now
+                } : {}
+            });
+            breakers.set(fx.effect, created);
+            return created;
+        })();
+        const gate = br?.canAttempt() ?? {
+            allowed: true,
+            state: 'closed'
+        };
+        if (!gate.allowed) {
+            const trace = {
+                effect: fx.effect,
+                channel: spec.channel,
+                attempts: 0,
+                backoffMs: 0,
+                breaker: gate.state,
+                declined: 'circuit-open',
+                evidence: [
+                    `[效应:${fx.effect}@${ts}] breaker=${gate.state} 拒绝(冷却中,不重试)`
+                ]
+            };
+            return {
+                result: null,
+                trace
+            };
+        }
+        const policy = spec.retry ? {
+            maxAttempts: spec.retry.maxAttempts,
+            baseDelayMs: spec.retry.baseDelayMs,
+            maxDelayMs: spec.retry.maxDelayMs,
+            isRetryable: spec.isRetryable,
+            sleep
+        } : {
+            maxAttempts: 1,
+            baseDelayMs: 0,
+            maxDelayMs: 0,
+            sleep
+        };
+        const dispatch = handler;
+        const outcome = await withRetry(()=>dispatch(fx.params), policy);
+        const failed = outcome.error != null || spec.isFailure(outcome.result);
+        if (br) failed ? br.onFailure() : br.onSuccess();
+        const breakerState = br?.state() ?? 'off';
+        const evidence = [
+            `[效应:${fx.effect}@${ts}] attempts=${outcome.attempts} backoff=${outcome.backoffMs}ms breaker=${breakerState}`
+        ];
+        return {
+            result: outcome.error != null ? null : outcome.result,
+            trace: {
+                effect: fx.effect,
+                channel: spec.channel,
+                attempts: outcome.attempts,
+                backoffMs: outcome.backoffMs,
+                breaker: breakerState,
+                evidence
+            }
+        };
+    };
+}
+export const productionInterpreter = makeProductionInterpreter();
+export async function interpretEffect(fx) {
+    return productionInterpreter(fx);
+}
+export function makeMockInterpreter(fixtures) {
+    return async (fx)=>{
+        const ts = new Date().toISOString();
+        const registered = Object.prototype.hasOwnProperty.call(fixtures, fx.effect);
+        if (!registered) {
+            return {
+                result: null,
+                trace: {
+                    effect: fx.effect,
+                    channel: 'mock',
+                    attempts: 0,
+                    backoffMs: 0,
+                    breaker: 'off',
+                    declined: 'unknown-effect',
+                    evidence: [
+                        `[效应:mock@${ts}] ${fx.effect} 未登记夹具`
+                    ]
+                }
+            };
+        }
+        return {
+            result: fixtures[fx.effect],
+            trace: {
+                effect: fx.effect,
+                channel: 'mock',
+                attempts: 1,
+                backoffMs: 0,
+                breaker: 'off',
+                evidence: [
+                    `[效应:mock@${ts}] ${fx.effect} 夹具回放(确定性,无网络)`
+                ]
+            }
+        };
+    };
+}
+export function selectInterpreter(env, opts = {}) {
+    return env === 'mock' ? makeMockInterpreter(opts.fixtures ?? {}) : makeProductionInterpreter(opts);
+}
+
+
+//# sourceURL=/Users/bytedance/work/gotry-publish/ts/capabilities/effect.ts

package/dist/capabilities/fact-log.js

@@ -0,0 +1,41 @@
+import { appendFile, mkdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { dedupeFacts } from '../src/bookable-facts.js';
+export const FACT_LOG_NAME = 'bookable-facts.jsonl';
+export function factLogPath(stateRoot) {
+    const root = stateRoot === '.' ? process.cwd() : stateRoot;
+    return join(root, 'gotry-state', FACT_LOG_NAME);
+}
+export async function appendFacts(stateRoot, facts) {
+    if (facts.length === 0) return true;
+    try {
+        const p = factLogPath(stateRoot);
+        await mkdir(join(p, '..'), {
+            recursive: true
+        });
+        await appendFile(p, facts.map((f)=>JSON.stringify(f)).join('\n') + '\n', 'utf-8');
+        return true;
+    } catch  {
+        return false;
+    }
+}
+export async function loadFactRegistry(stateRoot) {
+    try {
+        const raw = await readFile(factLogPath(stateRoot), 'utf-8');
+        const facts = [];
+        for (const line of raw.split('\n')){
+            const t = line.trim();
+            if (!t) continue;
+            try {
+                const f = JSON.parse(t);
+                if (f.schema === 'gotry_bookable_fact.v1' && f.fact_id) facts.push(f);
+            } catch  {}
+        }
+        return dedupeFacts(facts);
+    } catch  {
+        return [];
+    }
+}
+
+
+//# sourceURL=/Users/bytedance/work/gotry-publish/ts/capabilities/fact-log.ts

package/dist/capabilities/flyai.js

@@ -233,4 +233,4 @@ function parseHotelItems(items) {
 }
 
 
-//# sourceURL=/Users/bytedance/work/gotry/ts/capabilities/flyai.ts
+//# sourceURL=/Users/bytedance/work/gotry-publish/ts/capabilities/flyai.ts

package/dist/capabilities/hbcli.js

@@ -177,6 +177,48 @@ export async function listDestinations(opts = {}) {
         destinations: r.result
     };
 }
+export async function hotelRates(query, opts = {}) {
+    const hbArgs = [
+        'search',
+        'hotel-rates',
+        '--json',
+        '--hotel-id',
+        query.hotelId
+    ];
+    if (query.checkIn) hbArgs.push('--check-in', query.checkIn);
+    if (query.checkOut) hbArgs.push('--check-out', query.checkOut);
+    if (query.countryCode) hbArgs.push('--country-code', query.countryCode);
+    if (query.nationalityCode) hbArgs.push('--nationality-code', query.nationalityCode);
+    if (query.residencyCode) hbArgs.push('--residency-code', query.residencyCode);
+    if (query.adults) hbArgs.push('--room-occupancies', JSON.stringify([
+        {
+            adultCount: query.adults,
+            childrenAges: []
+        }
+    ]));
+    const live = await callHbcliJson(hbArgs, opts);
+    const summary = live.via === 'hbcli-realtime' ? `hotel ${query.hotelId}:hbcli 实时报价${query.checkIn ? `(${query.checkIn} → ${query.checkOut ?? '?'})` : ''}` : `hotel ${query.hotelId}:hbcli 实时报价不可用(${live.error ?? live.via});价格面无静态降级,fail-closed 不估算`;
+    return {
+        ...live,
+        rates: live.result,
+        summary
+    };
+}
+export async function checkAvail(query, opts = {}) {
+    const live = await callHbcliJson([
+        'search',
+        'check-avail',
+        '--json',
+        '--rate-pkg-id',
+        query.ratePkgId
+    ], opts);
+    const summary = live.via === 'hbcli-realtime' ? `ratePkg ${query.ratePkgId}:hbcli 实时验价(库存与价格以后端为准)` : `ratePkg ${query.ratePkgId}:hbcli 实时验价不可用(${live.error ?? live.via});价格面无静态降级,fail-closed`;
+    return {
+        ...live,
+        avail: live.result,
+        summary
+    };
+}
 
 
-//# sourceURL=/Users/bytedance/work/gotry/ts/capabilities/hbcli.ts
+//# sourceURL=/Users/bytedance/work/gotry-publish/ts/capabilities/hbcli.ts

package/dist/capabilities/incident-log.js

@@ -97,4 +97,4 @@ if (import.meta.url === `file://${fileURLToPath(import.meta.url)}` && process.ar
 }
 
 
-//# sourceURL=/Users/bytedance/work/gotry/ts/capabilities/incident-log.ts
+//# sourceURL=/Users/bytedance/work/gotry-publish/ts/capabilities/incident-log.ts

package/dist/capabilities/opensky.js

@@ -71,4 +71,4 @@ export async function verifyFlight(query) {
 }
 
 
-//# sourceURL=/Users/bytedance/work/gotry/ts/capabilities/opensky.ts
+//# sourceURL=/Users/bytedance/work/gotry-publish/ts/capabilities/opensky.ts

package/dist/capabilities/resilience.js

@@ -0,0 +1,90 @@
+export function backoffDelayMs(policy, failedAttempt) {
+    const raw = policy.baseDelayMs * 2 ** (Math.max(1, failedAttempt) - 1);
+    return Math.min(raw, policy.maxDelayMs);
+}
+const defaultSleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
+export async function withRetry(fn, policy, onBackoff) {
+    const sleep = policy.sleep ?? defaultSleep;
+    const maxAttempts = Math.max(1, policy.maxAttempts);
+    let attempts = 0;
+    let backoffMs = 0;
+    for(;;){
+        attempts += 1;
+        let result = null;
+        let error = null;
+        try {
+            result = await fn();
+        } catch (e) {
+            error = e;
+        }
+        const retryable = policy.isRetryable?.(result, error) ?? (error != null || result?.ok === false);
+        if (attempts < maxAttempts && retryable) {
+            const delay = backoffDelayMs(policy, attempts);
+            onBackoff?.(attempts, delay);
+            backoffMs += delay;
+            await sleep(delay);
+            continue;
+        }
+        return {
+            result,
+            error,
+            attempts,
+            backoffMs
+        };
+    }
+}
+export class CircuitBreaker {
+    o;
+    consecutiveFailures = 0;
+    openedAt = 0;
+    probeInFlight = false;
+    constructor(o){
+        this.o = o;
+    }
+    threshold() {
+        return Math.max(1, this.o.failureThreshold);
+    }
+    now() {
+        return (this.o.now ?? Date.now)();
+    }
+    state() {
+        if (this.openedAt > 0 && this.now() - this.openedAt >= this.o.openMs) return 'half-open';
+        if (this.openedAt > 0) return 'open';
+        return 'closed';
+    }
+    canAttempt() {
+        const s = this.state();
+        if (s === 'closed') return {
+            allowed: true,
+            state: s
+        };
+        if (s === 'open') return {
+            allowed: false,
+            state: s
+        };
+        if (this.probeInFlight) return {
+            allowed: false,
+            state: s
+        };
+        this.probeInFlight = true;
+        return {
+            allowed: true,
+            state: s
+        };
+    }
+    onSuccess() {
+        this.consecutiveFailures = 0;
+        this.openedAt = 0;
+        this.probeInFlight = false;
+    }
+    onFailure() {
+        this.probeInFlight = false;
+        this.consecutiveFailures += 1;
+        if (this.openedAt > 0 || this.consecutiveFailures >= this.threshold()) {
+            this.openedAt = this.now();
+        }
+    }
+}
+
+
+//# sourceURL=/Users/bytedance/work/gotry-publish/ts/capabilities/resilience.ts

package/dist/capabilities/session/action-cache.js

@@ -117,4 +117,4 @@ export function actionCachePath(stateRoot) {
 }
 
 
-//# sourceURL=/Users/bytedance/work/gotry/ts/capabilities/session/action-cache.ts
+//# sourceURL=/Users/bytedance/work/gotry-publish/ts/capabilities/session/action-cache.ts

package/dist/capabilities/session/adapters/ctrip-flight.js

@@ -80,4 +80,4 @@ export function parseBatchSearch(body) {
 }
 
 
-//# sourceURL=/Users/bytedance/work/gotry/ts/capabilities/session/adapters/ctrip-flight.ts
+//# sourceURL=/Users/bytedance/work/gotry-publish/ts/capabilities/session/adapters/ctrip-flight.ts

package/dist/capabilities/session/adapters/meituan-local.js

@@ -70,4 +70,4 @@ export function extractListings(entries, opts = {}) {
 }
 
 
-//# sourceURL=/Users/bytedance/work/gotry/ts/capabilities/session/adapters/meituan-local.ts
+//# sourceURL=/Users/bytedance/work/gotry-publish/ts/capabilities/session/adapters/meituan-local.ts

package/dist/capabilities/session/benchmark.js

@@ -228,6 +228,7 @@ export function evaluateDoubleSource(input) {
     }
     if (!session) return baseEvaluation('source_unavailable', 'no_spend_stop');
     if (session.verdict === 'needs-attach') return baseEvaluation('waiting_attach', 'no_spend_waiting_user');
+    if (session.verdict === 'needs-extension') return baseEvaluation('waiting_extension', 'no_spend_waiting_user');
     if (session.verdict === 'needs-login') return baseEvaluation('waiting_login', 'no_spend_waiting_user');
     if (!official || official.verdict !== 'hit' || session.verdict !== 'hit') {
         return baseEvaluation('source_unavailable', 'no_spend_stop');
@@ -249,4 +250,4 @@ export function evaluateDoubleSource(input) {
 }
 
 
-//# sourceURL=/Users/bytedance/work/gotry/ts/capabilities/session/benchmark.ts
+//# sourceURL=/Users/bytedance/work/gotry-publish/ts/capabilities/session/benchmark.ts