@danceiny/gotry 0.0.1-rc.10

package/dist/capabilities/hbcli.js

@@ -0,0 +1,143 @@
+import { spawn } from 'node:child_process';
+export async function callHbcliJson(args, opts = {}) {
+    const started = Date.now();
+    const bin = opts.hbcliBin ?? 'hbcli';
+    const timeoutMs = opts.timeoutMs ?? 15_000;
+    const env = opts.env ?? 'uat';
+    const envVars = {
+        HOTELBYTE_ENV: env
+    };
+    if (opts.token) envVars['HOTELBYTE_TOKEN'] = opts.token;
+    return new Promise((resolve)=>{
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        const child = spawn(bin, args, {
+            env: {
+                ...process.env,
+                ...envVars
+            }
+        });
+        const timer = setTimeout(()=>{
+            if (!settled) {
+                settled = true;
+                child.kill('SIGKILL');
+                resolve({
+                    via: 'hbcli-error',
+                    exitCode: -1,
+                    result: null,
+                    evidence: `[实时API:hbcli@timeout@${new Date().toISOString()}]`,
+                    latencyMs: Date.now() - started,
+                    error: `timeout after ${timeoutMs}ms`
+                });
+            }
+        }, timeoutMs);
+        child.stdout.on('data', (d)=>{
+            stdout += d.toString();
+        });
+        child.stderr.on('data', (d)=>{
+            stderr += d.toString();
+        });
+        child.on('close', (code)=>{
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            const latencyMs = Date.now() - started;
+            if (code !== 0) {
+                resolve({
+                    via: 'hbcli-error',
+                    exitCode: code ?? -1,
+                    result: null,
+                    evidence: `[实时API:hbcli@error@${new Date().toISOString()}]`,
+                    stderr: stderr.slice(0, 2000),
+                    latencyMs,
+                    error: stderr.trim().slice(0, 200) || `exit ${code}`
+                });
+                return;
+            }
+            const jStart = stdout.search(/[\{\[]/);
+            const jsonStr = jStart >= 0 ? stdout.slice(jStart) : '';
+            let result = null;
+            if (jsonStr) {
+                try {
+                    result = JSON.parse(jsonStr);
+                } catch  {}
+            }
+            resolve({
+                via: 'hbcli-realtime',
+                exitCode: 0,
+                result,
+                evidence: `[实时API:hbcli@${new Date().toISOString()}]`,
+                stdout: stdout.slice(0, 2000),
+                latencyMs
+            });
+        });
+        child.on('error', (e)=>{
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({
+                via: 'hbcli-error',
+                exitCode: -1,
+                result: null,
+                evidence: `[实时API:hbcli@spawn_error@${new Date().toISOString()}]`,
+                latencyMs: Date.now() - started,
+                error: e.message
+            });
+        });
+    });
+}
+export async function searchHotels(query, opts = {}) {
+    const hbArgs = [
+        'search',
+        'hotel-list',
+        '--json',
+        '--page-size',
+        '10'
+    ];
+    if (query.destination) hbArgs.push('--destination-name', query.destination);
+    if (query.adults) hbArgs.push('--room-occupancies', JSON.stringify([
+        {
+            adultCount: query.adults,
+            childrenAges: []
+        }
+    ]));
+    const live = await callHbcliJson(hbArgs, opts);
+    if (live.via === 'hbcli-realtime') {
+        return {
+            ...live,
+            hotels: live.result,
+            summary: `${query.destination}:hbcli 实时返回${query.checkIn || query.checkOut ? '(日期不传上游 list,以当前窗口房价返回)' : ''}`
+        };
+    }
+    const fallback = opts.fallbackPath;
+    if (fallback) {
+        try {
+            const { readFile } = await import('node:fs/promises');
+            const pack = JSON.parse(await readFile(fallback, 'utf-8'));
+            return {
+                ...live,
+                hotels: pack,
+                summary: `${query.destination}:hbcli 不可用(${live.error ?? live.via}),降级到静态包`
+            };
+        } catch  {}
+    }
+    return {
+        ...live,
+        summary: `${query.destination}:hbcli 不可用且无静态包(仅返回错误)`
+    };
+}
+export async function listDestinations(opts = {}) {
+    const r = await callHbcliJson([
+        'search',
+        'destinations',
+        '--json'
+    ], opts);
+    return {
+        ...r,
+        destinations: r.result
+    };
+}
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/capabilities/hbcli.ts

package/dist/capabilities/incident-log.js

@@ -0,0 +1,100 @@
+import { appendFileSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, isAbsolute, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export function resolveIncidentsPath(stateRoot, filename = 'incidents.jsonl') {
+    const root = isAbsolute(stateRoot) ? stateRoot : join(process.cwd(), stateRoot);
+    return join(root, 'gotry-state', filename);
+}
+function ensureDir(path) {
+    const dir = dirname(path);
+    if (!existsSync(dir)) mkdirSync(dir, {
+        recursive: true
+    });
+}
+let installed = false;
+let logPath = null;
+export function recordIncident(inc, stateRoot) {
+    const target = stateRoot ? resolveIncidentsPath(stateRoot) : logPath ?? resolveIncidentsPath('.');
+    try {
+        ensureDir(target);
+        appendFileSync(target, JSON.stringify(inc) + '\n', {
+            flag: 'a'
+        });
+        const fd = require('node:fs').openSync(target, 'a');
+        require('node:fs').fsyncSync(fd);
+        require('node:fs').closeSync(fd);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+export function installProcessGuards(stateRoot, labels) {
+    if (installed) return ()=>{};
+    installed = true;
+    logPath = resolveIncidentsPath(stateRoot);
+    const uncaughtHandler = (err, origin)=>{
+        recordIncident({
+            ts: new Date().toISOString(),
+            kind: 'uncaughtException',
+            message: (err?.message ?? String(err)).slice(0, 2000),
+            stack: (err?.stack ?? '').slice(0, 4000),
+            source: labels?.uncaughtException ?? String(origin)
+        }, stateRoot);
+    };
+    const rejectionHandler = (reason, promise)=>{
+        const msg = reason instanceof Error ? reason.message : String(reason);
+        const stack = reason instanceof Error ? reason.stack ?? '' : '';
+        recordIncident({
+            ts: new Date().toISOString(),
+            kind: 'unhandledRejection',
+            message: msg.slice(0, 2000),
+            stack: stack.slice(0, 4000),
+            source: labels?.unhandledRejection ?? 'promise'
+        }, stateRoot);
+    };
+    process.on('uncaughtException', uncaughtHandler);
+    process.on('unhandledRejection', rejectionHandler);
+    return ()=>{
+        process.off('uncaughtException', uncaughtHandler);
+        process.off('unhandledRejection', rejectionHandler);
+        installed = false;
+    };
+}
+export function guardToolExecute(name, stateRoot, execute) {
+    return async (args, exec)=>{
+        try {
+            return await execute(args, exec);
+        } catch (e) {
+            const err = e instanceof Error ? e : new Error(String(e));
+            recordIncident({
+                ts: new Date().toISOString(),
+                kind: 'tool_execute_error',
+                message: `${name}: ${err.message}`.slice(0, 2000),
+                stack: (err.stack ?? '').slice(0, 4000),
+                source: name
+            }, stateRoot);
+            const failure = {
+                ok: false,
+                summary: `gotry_${name} 内部错误(已隔离,会话继续): ${err.message.slice(0, 300)}`,
+                evidence: `[incident:tool_execute_error@${new Date().toISOString()}]`
+            };
+            return failure;
+        }
+    };
+}
+if (import.meta.url === `file://${fileURLToPath(import.meta.url)}` && process.argv[2] === '--smoke') {
+    const stateRoot = process.argv[3] ?? '.';
+    installProcessGuards(stateRoot, {
+        uncaughtException: 'smoke',
+        unhandledRejection: 'smoke'
+    });
+    writeFileSync(resolveIncidentsPath(stateRoot) + '.smoke', 'ok');
+    setTimeout(()=>Promise.reject(new Error('intentional smoke-rejection')), 50);
+    setTimeout(()=>{
+        console.log('SMOKE OK');
+        process.exit(0);
+    }, 500);
+}
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/capabilities/incident-log.ts

package/dist/capabilities/opensky.js

@@ -0,0 +1,74 @@
+const BASE = 'https://opensky-network.org/api';
+async function fetchOpenSky(url, timeoutMs) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(()=>ctrl.abort(), timeoutMs);
+    try {
+        const res = await fetch(url, {
+            signal: ctrl.signal,
+            headers: {
+                Accept: 'application/json',
+                'User-Agent': 'gotry/0.0.1-rc.3 (+https://github.com/Danceiny/gotry)'
+            }
+        });
+        if (!res.ok) return {
+            ok: false,
+            error: `opensky HTTP ${res.status}${res.status === 429 ? ' (rate limited, 400 credits/day anonymous)' : ''}`
+        };
+        return {
+            ok: true,
+            data: await res.json()
+        };
+    } catch (e) {
+        return {
+            ok: false,
+            error: e.message.slice(0, 200)
+        };
+    } finally{
+        clearTimeout(timer);
+    }
+}
+const upper = (s)=>s.trim().toUpperCase();
+export async function verifyFlight(query) {
+    const started = Date.now();
+    const ts = new Date().toISOString();
+    const cs = upper(query.callsign);
+    const airport = query.airport ? upper(query.airport) : null;
+    const r = await fetchOpenSky(`${BASE}/states/all`, query.timeoutMs ?? 10_000);
+    const latencyMs = Date.now() - started;
+    if (!r.ok) {
+        return {
+            verdict: 'unavailable',
+            callsign: cs,
+            airport,
+            sampleSize: 0,
+            hits: [],
+            evidence: `[实时API:opensky@error@${ts}] ${r.error}`,
+            via: 'opensky-error',
+            latencyMs,
+            error: r.error
+        };
+    }
+    const rawStates = (r.data ?? {}).states ?? [];
+    const observed = rawStates.filter((row)=>(row[1] ?? '').trim().toUpperCase().includes(cs)).map((row)=>({
+            icao24: String(row[0] ?? ''),
+            callsign: (row[1] ?? '').trim() || null,
+            lastSeen: Number(row[4] ?? 0),
+            firstSeen: Number(row[4] ?? 0),
+            estArrivalAirport: airport
+        }));
+    const verdict = observed.length > 0 ? 'observed' : 'not_observed';
+    const evidence = observed.length > 0 ? `[实时API:opensky@${ts}] ✅ 全球 ADS-B 当前观测命中 ${cs} (${observed.length} 架)` : `[实时API:opensky@${ts}] ○ 当前 ADS-B 全球观测列表未见 ${cs}(ADS-B 覆盖有限,不作否定结论)`;
+    return {
+        verdict,
+        callsign: cs,
+        airport,
+        sampleSize: rawStates.length,
+        hits: observed,
+        evidence,
+        via: 'opensky',
+        latencyMs
+    };
+}
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/capabilities/opensky.ts

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

@@ -0,0 +1,120 @@
+import { createHash } from 'node:crypto';
+import { mkdirSync, readFileSync, writeFileSync, existsSync, rmSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+export function templateKey(site, action, params) {
+    const val = (k)=>k === 'date' ? '%date%' : (params[k] ?? '').trim();
+    const head = [
+        'from',
+        'to',
+        'date'
+    ].filter((k)=>k in params).map(val);
+    const tail = Object.keys(params).filter((k)=>![
+            'from',
+            'to',
+            'date'
+        ].includes(k)).sort().map(val);
+    return `${site}:${action}:${[
+        ...head,
+        ...tail
+    ].join('|')}`;
+}
+export function fingerprint(shapeText) {
+    return createHash('sha256').update(shapeText).digest('hex').slice(0, 16);
+}
+export class ActionCache {
+    filePath;
+    entries = new Map();
+    loaded = false;
+    ttlMs;
+    maxPerSite;
+    now;
+    constructor(filePath, opts = {}){
+        this.filePath = filePath;
+        this.ttlMs = opts.ttlMs ?? 48 * 3600_000;
+        this.maxPerSite = opts.maxEntriesPerSite ?? 50;
+        this.now = opts.now ?? (()=>new Date());
+    }
+    load() {
+        if (this.loaded) return;
+        this.loaded = true;
+        try {
+            if (existsSync(this.filePath)) {
+                const raw = JSON.parse(readFileSync(this.filePath, 'utf8'));
+                for (const e of raw){
+                    if (e?.key && e.domFingerprint && e.locator) this.entries.set(e.key, e);
+                }
+            }
+        } catch  {}
+    }
+    persist() {
+        try {
+            mkdirSync(dirname(this.filePath), {
+                recursive: true
+            });
+            const tmp = this.filePath + '.tmp';
+            writeFileSync(tmp, JSON.stringify([
+                ...this.entries.values()
+            ], null, 0), 'utf8');
+            writeFileSync(this.filePath, readFileSync(tmp, 'utf8'), 'utf8');
+            try {
+                require('node:fs').rmSync(tmp);
+            } catch  {}
+        } catch  {}
+    }
+    siteEntries(site) {
+        return [
+            ...this.entries.values()
+        ].filter((e)=>e.key.startsWith(site + ':'));
+    }
+    lookup(key, domFingerprint, site) {
+        this.load();
+        const e = this.entries.get(key);
+        if (!e) return null;
+        if (this.now().getTime() - Date.parse(e.lastHitAt || e.createdAt) > this.ttlMs) {
+            this.entries.delete(key);
+            this.persist();
+            return null;
+        }
+        if (e.domFingerprint !== domFingerprint) return null;
+        e.hits += 1;
+        e.lastHitAt = this.now().toISOString();
+        this.persist();
+        void site;
+        return e;
+    }
+    record(key, domFingerprint, locator, site) {
+        this.load();
+        const ts = this.now().toISOString();
+        const prev = this.entries.get(key);
+        this.entries.set(key, {
+            key,
+            domFingerprint,
+            locator,
+            createdAt: prev?.createdAt ?? ts,
+            lastHitAt: ts,
+            hits: prev?.hits ?? 0
+        });
+        const siteList = this.siteEntries(site);
+        if (siteList.length > this.maxPerSite) {
+            const victim = siteList.sort((a, b)=>Date.parse(a.lastHitAt) - Date.parse(b.lastHitAt))[0];
+            if (victim) this.entries.delete(victim.key);
+        }
+        this.persist();
+        return this.entries.get(key);
+    }
+    invalidate(key) {
+        this.load();
+        this.entries.delete(key);
+        this.persist();
+    }
+    size(site) {
+        this.load();
+        return site ? this.siteEntries(site).length : this.entries.size;
+    }
+}
+export function actionCachePath(stateRoot) {
+    return join(stateRoot, 'session-action-cache.json');
+}
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/capabilities/session/action-cache.ts

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

@@ -0,0 +1,83 @@
+const CITY_CODES = {
+    上海: 'sha',
+    北京: 'bjs',
+    广州: 'can',
+    深圳: 'szx',
+    成都: 'ctu',
+    昆明: 'kmg',
+    大理: 'dlu',
+    丽江: 'ljg',
+    西安: 'sia',
+    杭州: 'hgh',
+    三亚: 'syx',
+    厦门: 'xmn',
+    重庆: 'cqg',
+    青岛: 'taa',
+    长沙: 'csx',
+    武汉: 'wuh',
+    南京: 'nkg',
+    郑州: 'cgo',
+    贵阳: 'kwe',
+    桂林: 'kwl',
+    西双版纳: 'jhg',
+    香格里拉: 'dig'
+};
+export function buildEntryUrl(from, to, depDate) {
+    const unresolved = [];
+    const fromCode = CITY_CODES[from];
+    const toCode = CITY_CODES[to];
+    if (!fromCode) unresolved.push(from);
+    if (!toCode) unresolved.push(to);
+    if (unresolved.length > 0 || !/^\d{4}-\d{2}-\d{2}$/.test(depDate)) {
+        return {
+            ok: false,
+            unresolved: unresolved.length > 0 ? unresolved : [
+                depDate
+            ]
+        };
+    }
+    return {
+        ok: true,
+        url: `https://flights.ctrip.com/online/list/oneway-${fromCode}-${toCode}?depdate=${depDate}`
+    };
+}
+export const NETWORK_HINTS = [
+    /search\/api\/search\/batchSearch/
+];
+export const LOGIN_COOKIE_NAMES = [
+    'cticket',
+    'uid',
+    'uname',
+    'passport'
+];
+export const SITE_DOMAIN = '.ctrip.com';
+export function parseBatchSearch(body) {
+    let raw;
+    try {
+        raw = JSON.parse(body);
+    } catch  {
+        return [];
+    }
+    const out = [];
+    for (const it of raw.data?.flightItineraryList ?? []){
+        const seg = it.flightSegments?.[0];
+        const fl = seg?.flightList?.[0];
+        if (!fl?.flightNo || !fl.departureDateTime) continue;
+        const prices = (it.priceList ?? []).map((p)=>Number(p.adultPrice ?? 0)).filter((n)=>n > 0);
+        out.push({
+            flightNo: fl.flightNo,
+            airline: seg?.airlineName ?? '',
+            depDateTime: fl.departureDateTime ?? '',
+            arrDateTime: fl.arrivalDateTime ?? '',
+            depAirport: fl.departureAirportName ?? '',
+            arrAirport: fl.arrivalAirportName ?? '',
+            durationMin: Number(seg?.duration ?? 0) || 0,
+            price: prices.length > 0 ? Math.min(...prices) : 0,
+            aircraft: fl.aircraftName
+        });
+    }
+    return out;
+}
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/capabilities/session/adapters/ctrip-flight.ts

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

@@ -0,0 +1,73 @@
+const CITY_SLUGS = {
+    上海: 'shanghai',
+    北京: 'beijing',
+    广州: 'guangzhou',
+    深圳: 'shenzhen',
+    成都: 'chengdu',
+    昆明: 'kunming',
+    大理: 'dali',
+    丽江: 'lijiang',
+    西安: 'xian',
+    杭州: 'hangzhou',
+    三亚: 'sanya',
+    厦门: 'xiamen',
+    重庆: 'chongqing',
+    青岛: 'qingdao',
+    长沙: 'changsha',
+    武汉: 'wuhan',
+    南京: 'nanjing',
+    郑州: 'zhengzhou',
+    贵阳: 'guiyang',
+    桂林: 'guilin'
+};
+export const SITE_DOMAIN = 'meituan.com';
+export const LOGIN_COOKIE_NAMES = [
+    'lt',
+    'u',
+    'token',
+    'n'
+];
+export function buildMeituanEntry(city, vertical, keyword) {
+    const slug = CITY_SLUGS[city];
+    if (!slug) return {
+        ok: false,
+        unresolved: [
+            city
+        ]
+    };
+    const base = vertical === 'hotel' ? `https://hotel.meituan.com/${slug}/` : `https://minsu.meituan.com/${slug}/`;
+    return {
+        ok: true,
+        url: keyword ? base + `?q=${encodeURIComponent(keyword)}` : base
+    };
+}
+export const NETWORK_HINTS = [];
+export function parseMeituanSearch(_body) {
+    void _body;
+    return [];
+}
+export function extractListings(entries, opts = {}) {
+    const out = [];
+    const roles = new Set([
+        'heading',
+        'listitem',
+        'link',
+        'article'
+    ]);
+    for (const e of entries){
+        if (out.length >= (opts.max ?? 30)) break;
+        if (!roles.has(e.role) || !e.name) continue;
+        const pm = /¥\s*(\d+)/.exec(e.name);
+        if (!pm) continue;
+        const name = e.name.replace(/¥\s*\d+.*$/, '').trim().slice(0, 80);
+        if (!name) continue;
+        out.push({
+            name,
+            price: Number(pm[1])
+        });
+    }
+    return out;
+}
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/capabilities/session/adapters/meituan-local.ts

package/dist/capabilities/session/extract.js

@@ -0,0 +1,40 @@
+export function extractA11yEntries(snapshotText, opts = {}) {
+    const cap = opts.maxEntries ?? 500;
+    const out = [];
+    const lines = snapshotText.split('\n');
+    for(let i = 0; i < lines.length && out.length < cap; i++){
+        const m = /^[\s*-]*\s*([a-zA-Z][\w-]*)(?:\s+"((?:[^"\\]|\\.)*)")?/.exec(lines[i] ?? '');
+        if (!m) continue;
+        const name = (m[2] ?? '').replace(/\\"/g, '"').slice(0, 200);
+        out.push({
+            role: m[1].toLowerCase(),
+            name,
+            line: i
+        });
+    }
+    return out;
+}
+export function filterSubmitEntries(entries, isSubmit) {
+    const interactive = new Set([
+        'button',
+        'link',
+        'menuitem',
+        'option'
+    ]);
+    return entries.filter((e)=>!(interactive.has(e.role) && isSubmit(e.name)));
+}
+export function nameAffinity(a, b) {
+    const x = a.trim();
+    const y = b.trim();
+    if (!x || !y) return 0;
+    if (x === y) return 1;
+    if (x.includes(y) || y.includes(x)) return 0.8;
+    const sa = new Set(x);
+    const sb = new Set(y);
+    let common = 0;
+    for (const ch of sa)if (sb.has(ch)) common += 1;
+    return common / Math.max(sa.size, sb.size);
+}
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/capabilities/session/extract.ts