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

package/dist/capabilities/session/health-watch.js

@@ -0,0 +1,216 @@
+import { request } from 'node:http';
+import { BRIDGE_PORTS, EXTENSION_CONNECTED_WINDOW_MS } from './extension-bridge.js';
+export async function combinedProbe(opts, businessProbe) {
+    if (!await defaultProbe(opts)) return false;
+    if (!businessProbe) return true;
+    try {
+        const channel = await import('./extension-channel.js');
+        const bridge = await import('./extension-bridge.js');
+        bridge.getOrCreateSessionBridge({
+            keepBridge: opts.keepBridge === true
+        });
+        const cookie = await channel.extensionCookieNames({
+            site: 'ctrip-flight',
+            domain: 'ctrip.com',
+            ticketNames: [
+                'cticket',
+                'uid'
+            ],
+            timeoutMs: 8_000
+        });
+        return cookie.ok;
+    } catch  {
+        return false;
+    }
+}
+export async function defaultProbe(opts) {
+    const ports = opts.ports ?? [
+        ...BRIDGE_PORTS
+    ];
+    for (const port of ports){
+        const ok = await new Promise((resolve)=>{
+            const req = request({
+                host: '127.0.0.1',
+                port,
+                path: '/status',
+                method: 'GET',
+                timeout: 2_000
+            }, (res)=>{
+                if (!res.statusCode || res.statusCode >= 400) {
+                    resolve(false);
+                    return;
+                }
+                let buf = '';
+                res.setEncoding('utf8');
+                res.on('data', (c)=>{
+                    buf += c;
+                });
+                res.on('end', ()=>{
+                    try {
+                        const payload = JSON.parse(buf);
+                        resolve(payload.extensionConnected === true);
+                    } catch  {
+                        resolve(false);
+                    }
+                });
+                res.on('error', ()=>resolve(false));
+            });
+            req.on('error', ()=>resolve(false));
+            req.on('timeout', ()=>{
+                req.destroy();
+                resolve(false);
+            });
+            req.end();
+        });
+        if (ok) return true;
+    }
+    return false;
+}
+export function startExtensionHealthWatch(opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? 120_000;
+    const intervalMs = opts.intervalMs ?? 5_000;
+    const maxRetries = opts.maxRetries ?? 1;
+    const businessProbe = opts.businessProbe ?? true;
+    const probe = opts.probe ?? (async ()=>{
+        const bridge = await import('./extension-bridge.js');
+        await bridge.getOrCreateSessionBridge({
+            keepBridge: opts.keepBridge === true
+        });
+        return combinedProbe(opts, businessProbe);
+    });
+    const now = opts.now ?? Date.now;
+    const state = {
+        cancelled: false,
+        readyCount: 0,
+        resolveOutcome: null
+    };
+    const finish = (outcome)=>{
+        if (state.resolveOutcome) {
+            const resolve = state.resolveOutcome;
+            state.resolveOutcome = null;
+            resolve(outcome);
+        }
+    };
+    const onAbort = ()=>{
+        state.cancelled = true;
+        finish({
+            ready: false,
+            reason: 'cancelled',
+            attempts: state.readyCount,
+            waitedMs: 0
+        });
+    };
+    opts.signal?.addEventListener('abort', onAbort, {
+        once: true
+    });
+    const waitReady = ()=>new Promise((resolve)=>{
+            if (state.cancelled) {
+                resolve({
+                    ready: false,
+                    reason: 'cancelled',
+                    attempts: 0,
+                    waitedMs: 0
+                });
+                return;
+            }
+            if (timeoutMs === 0) {
+                resolve({
+                    ready: false,
+                    reason: 'timeout',
+                    attempts: 0,
+                    waitedMs: 0
+                });
+                return;
+            }
+            state.resolveOutcome = resolve;
+            const deadline = now() + timeoutMs;
+            let attempts = 0;
+            let waitedMs = 0;
+            const tick = async ()=>{
+                if (state.cancelled || state.resolveOutcome === null) return;
+                attempts += 1;
+                try {
+                    const ready = await probe();
+                    if (ready && !state.cancelled) {
+                        state.readyCount += 1;
+                        waitedMs = timeoutMs - Math.max(0, deadline - now());
+                        if (state.readyCount <= maxRetries) {
+                            finish({
+                                ready: true,
+                                attempts,
+                                waitedMs: waitedMs > 0 ? waitedMs : 0
+                            });
+                            return;
+                        }
+                    }
+                } catch  {}
+                waitedMs = timeoutMs - Math.max(0, deadline - now());
+                if (now() >= deadline) {
+                    finish({
+                        ready: false,
+                        reason: 'timeout',
+                        attempts,
+                        waitedMs
+                    });
+                    return;
+                }
+                const remaining = deadline - now();
+                const delay = Math.min(intervalMs, Math.max(0, remaining));
+                if (delay <= 0) {
+                    finish({
+                        ready: false,
+                        reason: 'timeout',
+                        attempts,
+                        waitedMs
+                    });
+                    return;
+                }
+                setTimeout(tick, delay);
+            };
+            void tick();
+        });
+    return {
+        waitReady,
+        cancel: ()=>onAbort(),
+        get readyCount () {
+            return state.readyCount;
+        }
+    };
+}
+export async function withAutoRetryOnExtension(args) {
+    const first = await args.fetch();
+    if (!args.isExtensionNeeded(first)) {
+        return {
+            result: first,
+            retried: false,
+            attempts: 1,
+            outcome: {
+                ready: true,
+                attempts: 0,
+                waitedMs: 0
+            }
+        };
+    }
+    const watch = startExtensionHealthWatch(args.watch ?? {});
+    const outcome = await watch.waitReady();
+    if (!outcome.ready) {
+        return {
+            result: first,
+            retried: false,
+            attempts: 1,
+            outcome
+        };
+    }
+    const retriedResult = await (args.retry ?? args.fetch)();
+    return {
+        result: retriedResult,
+        retried: true,
+        attempts: 2,
+        outcome
+    };
+}
+export const HEALTH_WATCH_INTERVAL_FLOOR_MS = 1_000;
+export const HEALTH_WATCH_INTERVAL_CEIL_MS = EXTENSION_CONNECTED_WINDOW_MS - 1_000;
+
+
+//# sourceURL=/Users/bytedance/work/gotry-publish/ts/capabilities/session/health-watch.ts

package/dist/capabilities/session/read-guard.js

@@ -96,4 +96,4 @@ export async function attachReadGuardPuppeteer(browser, auditPath) {
 }
 
 
-//# sourceURL=/Users/bytedance/work/gotry/ts/capabilities/session/read-guard.ts
+//# sourceURL=/Users/bytedance/work/gotry-publish/ts/capabilities/session/read-guard.ts

package/dist/capabilities/session/transport.js

@@ -113,4 +113,4 @@ export async function openSession(opts = {}) {
 }
 
 
-//# sourceURL=/Users/bytedance/work/gotry/ts/capabilities/session/transport.ts
+//# sourceURL=/Users/bytedance/work/gotry-publish/ts/capabilities/session/transport.ts

package/dist/capabilities/session/wizard.js

@@ -0,0 +1,377 @@
+import { spawn } from 'node:child_process';
+import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from 'node:fs';
+import { homedir, platform } from 'node:os';
+import { join } from 'node:path';
+const DEFAULT_SOURCE_DIR_CANDIDATES = [
+    join(process.cwd(), 'extension'),
+    join(process.cwd(), 'dist', 'extension'),
+    join(process.cwd(), 'ts', '..', 'extension')
+];
+function resolveExtensionSourceDir() {
+    for (const candidate of DEFAULT_SOURCE_DIR_CANDIDATES){
+        if (existsSync(join(candidate, 'manifest.json'))) return candidate;
+    }
+    return DEFAULT_SOURCE_DIR_CANDIDATES[0];
+}
+export function defaultExtensionDir() {
+    return join(homedir(), '.gotry', 'extension');
+}
+function detectPlatform(force) {
+    if (force) return force;
+    if (process.env.GOTRY_ONBOARDING_HEADLESS === '1') return 'headless';
+    const p = platform();
+    if (p === 'darwin' || p === 'linux' || p === 'win32') {
+        if (p !== 'darwin' && !process.env.DISPLAY) return 'headless';
+        return p;
+    }
+    return 'headless';
+}
+function ensureExtensionFiles(source, target, dryRun) {
+    if (dryRun) return {
+        step: 'ensure-extension-files',
+        status: 'skip',
+        summary: '[dry-run] skip 扩展落位'
+    };
+    try {
+        if (!existsSync(source) || !existsSync(join(source, 'manifest.json'))) {
+            return {
+                step: 'ensure-extension-files',
+                status: 'fail',
+                summary: `源扩展目录缺失 manifest.json: ${source}(先跑 npx gotry setup 落位)`
+            };
+        }
+        mkdirSync(target, {
+            recursive: true
+        });
+        const required = [
+            'manifest.json',
+            'background.js',
+            'content-main.js',
+            'content-bridge.js'
+        ];
+        for (const f of required){
+            const src = join(source, f);
+            if (!existsSync(src)) return {
+                step: 'ensure-extension-files',
+                status: 'fail',
+                summary: `源扩展缺 ${f}(重新 npm install 或 gotry setup)`
+            };
+            copyFileSync(src, join(target, f));
+        }
+        return {
+            step: 'ensure-extension-files',
+            status: 'ok',
+            summary: `扩展已落位 ${target}(manifest+3 文件)`
+        };
+    } catch (e) {
+        return {
+            step: 'ensure-extension-files',
+            status: 'fail',
+            summary: `扩展落位失败: ${e instanceof Error ? e.message.slice(0, 120) : String(e)}`
+        };
+    }
+}
+function openChromeExtensions(sp, plat, dryRun) {
+    if (dryRun) return {
+        step: 'open-chrome-extensions',
+        status: 'skip',
+        summary: '[dry-run] skip 打开 chrome://extensions'
+    };
+    if (plat === 'headless') return {
+        step: 'open-chrome-extensions',
+        status: 'skip',
+        summary: 'headless 环境跳过 GUI;请在你桌面 Chrome 手动打开 chrome://extensions'
+    };
+    const cmd = (()=>{
+        if (plat === 'darwin') return {
+            bin: 'open',
+            args: [
+                '-a',
+                'Google Chrome',
+                'chrome://extensions'
+            ]
+        };
+        if (plat === 'linux') return {
+            bin: 'xdg-open',
+            args: [
+                'chrome://extensions'
+            ]
+        };
+        return {
+            bin: 'cmd',
+            args: [
+                '/c',
+                'start',
+                'chrome',
+                'chrome://extensions'
+            ]
+        };
+    })();
+    try {
+        const child = sp(cmd.bin, cmd.args, {
+            detached: true,
+            stdio: 'ignore'
+        });
+        child.unref?.();
+        return {
+            step: 'open-chrome-extensions',
+            status: 'ok',
+            summary: `已打开 chrome://extensions(${plat})`
+        };
+    } catch (e) {
+        return {
+            step: 'open-chrome-extensions',
+            status: 'fail',
+            summary: `自动打开失败: ${e instanceof Error ? e.message.slice(0, 80) : String(e)};请手开 chrome://extensions`
+        };
+    }
+}
+async function clipboardExtensionPath(sp, plat, path, dryRun) {
+    if (dryRun) return {
+        step: 'clipboard-extension-path',
+        status: 'skip',
+        summary: '[dry-run] skip 剪贴板复制'
+    };
+    if (plat === 'headless') return {
+        step: 'clipboard-extension-path',
+        status: 'skip',
+        summary: `headless 无剪贴板;扩展目录路径:${path}`
+    };
+    const cmd = (()=>{
+        if (plat === 'darwin') return {
+            bin: 'pbcopy',
+            args: []
+        };
+        if (plat === 'linux') return {
+            bin: 'xclip',
+            args: [
+                '-selection',
+                'clipboard'
+            ]
+        };
+        return {
+            bin: 'clip',
+            args: []
+        };
+    })();
+    return new Promise((resolveStep)=>{
+        let child;
+        try {
+            child = sp(cmd.bin, cmd.args, {
+                stdio: [
+                    'pipe',
+                    'ignore',
+                    'ignore'
+                ]
+            });
+        } catch  {
+            resolveStep({
+                step: 'clipboard-extension-path',
+                status: 'skip',
+                summary: `剪贴板工具不可用(${cmd.bin});扩展目录路径手动复制: ${path}`
+            });
+            return;
+        }
+        let settled = false;
+        const settle = (s)=>{
+            if (settled) return;
+            settled = true;
+            resolveStep(s);
+        };
+        child.on('error', ()=>settle({
+                step: 'clipboard-extension-path',
+                status: 'skip',
+                summary: `剪贴板工具启动失败(${cmd.bin});扩展目录路径手动复制: ${path}`
+            }));
+        child.on('exit', (code)=>{
+            if (code === 0) settle({
+                step: 'clipboard-extension-path',
+                status: 'ok',
+                summary: `已复制扩展目录到剪贴板: ${path}`
+            });
+            else settle({
+                step: 'clipboard-extension-path',
+                status: 'fail',
+                summary: `剪贴板工具退出码 ${code}(${cmd.bin});扩展目录路径手动复制: ${path}`
+            });
+        });
+        try {
+            child.stdin?.write(path);
+            child.stdin?.end();
+        } catch  {
+            settle({
+                step: 'clipboard-extension-path',
+                status: 'skip',
+                summary: `剪贴板工具 stdin 不可写(${cmd.bin});扩展目录路径手动复制: ${path}`
+            });
+        }
+    });
+}
+function panelGuideTerminal(plat, extensionDir, watchMs) {
+    const lines = [
+        '┌─ GoTry 扩展安装 ─────────────────────────────────┐',
+        '│  共 3 步,约 30 秒,装完零弹窗                     │',
+        '│                                                   │',
+        '│  ① 在 Chrome 右上角开启「开发者模式」             │',
+        `│  ② 点「加载已解压的扩展程序」选这个目录(已复制):  │`,
+        `│     ${extensionDir}`,
+        '│  ③ 弹窗「添加扩展」点「添加」                    │',
+        `│                                                   │`,
+        `│  后台探活中(最长 ${Math.round(watchMs / 1000)}s)…         │`,
+        '└───────────────────────────────────────────────────┘'
+    ];
+    if (plat === 'headless') {
+        process.stdout.write(lines.join('\n') + '\n');
+        return {
+            step: 'panel-guide',
+            status: 'skip',
+            summary: 'headless 终端面板已打印'
+        };
+    }
+    process.stdout.write(lines.join('\n') + '\n');
+    return {
+        step: 'panel-guide',
+        status: 'skip',
+        summary: '终端面板已打印(GUI 面板降级)'
+    };
+}
+function panelGuideGui(sp, plat, extensionDir, dryRun) {
+    if (dryRun) return {
+        step: 'panel-guide',
+        status: 'skip',
+        summary: '[dry-run] skip GUI 面板'
+    };
+    if (plat === 'headless') return panelGuideTerminal(plat, extensionDir, 120_000);
+    const message = `在 Chrome 右上角开启「开发者模式」 → 点「加载已解压的扩展程序」 → 选择(已复制):${extensionDir} → 弹窗点「添加扩展」`;
+    try {
+        if (plat === 'darwin') {
+            const script = `display dialog "${message.replace(/"/g, '\\"')}" with title "GoTry 扩展安装" buttons {"我装好了"} default button 1`;
+            sp('osascript', [
+                '-e',
+                script
+            ], {
+                stdio: 'ignore',
+                detached: true
+            }).unref?.();
+            return {
+                step: 'panel-guide',
+                status: 'ok',
+                summary: '已弹 macOS Cocoa 引导面板'
+            };
+        }
+        if (plat === 'linux') {
+            const child = sp('zenity', [
+                '--info',
+                '--title=GoTry 扩展安装',
+                `--text=${message}`
+            ], {
+                stdio: 'ignore',
+                detached: true
+            });
+            child.unref?.();
+            child.on('error', ()=>{
+                process.stdout.write(`(zenity 不可用,走终端面板)扩展目录: ${extensionDir}\n`);
+            });
+            return {
+                step: 'panel-guide',
+                status: 'ok',
+                summary: '已弹 zenity 引导面板'
+            };
+        }
+        return panelGuideTerminal(plat, extensionDir, 120_000);
+    } catch (e) {
+        return panelGuideTerminal(plat, extensionDir, 120_000);
+    }
+}
+async function watchExtensionReady(dryRun, sourceDir, extensionDir) {
+    if (dryRun) return {
+        step: 'watch-extension-ready',
+        status: 'skip',
+        summary: '[dry-run] skip health-watch'
+    };
+    if (!existsSync(extensionDir) || !existsSync(join(extensionDir, 'manifest.json'))) {
+        return {
+            step: 'watch-extension-ready',
+            status: 'fail',
+            summary: `落位缺失 manifest.json:${extensionDir}`
+        };
+    }
+    const srcStat = statSync(sourceDir);
+    const dstStat = statSync(extensionDir);
+    if (srcStat.mtimeMs > dstStat.mtimeMs) {
+        return {
+            step: 'watch-extension-ready',
+            status: 'fail',
+            summary: `扩展文件可能过期(源比落位新);重跑 npx gotry setup`
+        };
+    }
+    const manifest = JSON.parse(await (await import('node:fs/promises')).readFile(join(extensionDir, 'manifest.json'), 'utf8'));
+    if (typeof manifest.key !== 'string' || manifest.key.length < 100) {
+        return {
+            step: 'watch-extension-ready',
+            status: 'fail',
+            summary: 'manifest.key 缺失或过短,扩展 ID 不能稳定'
+        };
+    }
+    return {
+        step: 'watch-extension-ready',
+        status: 'ok',
+        summary: '扩展文件就绪(manifest.key 校验通过,后台轮询就绪态由 health-watch 接管)'
+    };
+}
+export async function runOnboardingWizard(opts = {}) {
+    const sp = opts.spawn ?? spawn;
+    const dryRun = opts.dryRun ?? false;
+    const plat = detectPlatform(opts.forcePlatform);
+    const extensionDir = opts.extensionDir ?? defaultExtensionDir();
+    const sourceDir = opts.sourceDir ?? resolveExtensionSourceDir();
+    const steps = [];
+    steps.push(ensureExtensionFiles(sourceDir, extensionDir, dryRun));
+    steps.push(openChromeExtensions(sp, plat, dryRun));
+    if (plat !== 'headless') {
+        steps.push(await clipboardExtensionPath(sp, plat, extensionDir, dryRun));
+        steps.push(panelGuideGui(sp, plat, extensionDir, dryRun));
+    } else {
+        steps.push({
+            step: 'clipboard-extension-path',
+            status: 'skip',
+            summary: 'headless 跳过剪贴板'
+        });
+        steps.push(panelGuideTerminal(plat, extensionDir, 120_000));
+    }
+    steps.push(await watchExtensionReady(dryRun, sourceDir, extensionDir));
+    const ok = steps.every((s)=>s.status !== 'fail');
+    return {
+        ok,
+        steps,
+        platform: plat,
+        extensionDir
+    };
+}
+export function printWizardResult(result, destination = process.stdout) {
+    const tag = (s)=>{
+        if (s.status === 'ok') return '✅';
+        if (s.status === 'skip') return '⏭ ';
+        return '❌';
+    };
+    for (const s of result.steps){
+        destination.write(`${tag(s)} ${s.step}: ${s.summary}\n`);
+    }
+    destination.write(`platform=${result.platform}; extensionDir=${result.extensionDir}; overall=${result.ok ? 'ok' : 'has-failures'}\n`);
+}
+export function describeExtensionDir(extensionDir) {
+    if (!existsSync(extensionDir)) return {
+        exists: false,
+        fileCount: 0,
+        hasManifest: false
+    };
+    const files = readdirSync(extensionDir);
+    return {
+        exists: true,
+        fileCount: files.length,
+        hasManifest: files.includes('manifest.json')
+    };
+}
+
+
+//# sourceURL=/Users/bytedance/work/gotry-publish/ts/capabilities/session/wizard.ts

package/dist/capabilities/session-consent.js

@@ -79,4 +79,4 @@ export function approvalFromContext(ctx) {
 }
 
 
-//# sourceURL=/Users/bytedance/work/gotry/ts/capabilities/session-consent.ts
+//# sourceURL=/Users/bytedance/work/gotry-publish/ts/capabilities/session-consent.ts