@danceiny/gotry 0.0.1-rc.8 → 0.2.0-rc.27

package/dist/src/backend/kernel.js

@@ -0,0 +1,91 @@
+/**
+ * gotry-backend 内核(2026-09-10,founder 口径:「我只允许一个 gotry 包装出来的服务」)。
+ *
+ * 形态:一个 HTTP 服务面 + 模块注册表。模块(gotry 能力单元)以 {method,path,handle}
+ * 精确路由表挂载,内核只做分发/404/异常隔离——鉴权、探活、schema 校验全部归模块
+ * 自持(模块行为即其独立部署形态的行为,挂载前后逐字一致)。
+ * 现有模块:booking-copilot(booking surface 能力)、session-search(账号会话检索)。
+ * gotry-a2a 是本服务的 A2A 协议端口,不是独立服务(迁移归部署收敛批次)。
+ */
+import { createServer } from 'node:http';
+export function createBackendServer(options) {
+    const table = new Map();
+    for (const module of options.modules) {
+        for (const route of module.routes) {
+            const key = `${route.method} ${route.path}`;
+            if (table.has(key))
+                throw new Error(`gotry_backend_route_conflict: ${key}`);
+            table.set(key, route);
+        }
+    }
+    const server = createServer(async (req, res) => {
+        const urlPath = (req.url ?? '').split('?')[0];
+        const route = table.get(`${req.method} ${urlPath}`);
+        if (!route) {
+            res.statusCode = 404;
+            res.setHeader('content-type', 'application/json');
+            res.end(JSON.stringify({ error: { code: 'not_found' } }));
+            return;
+        }
+        try {
+            await route.handle(req, res);
+        }
+        catch (error) {
+            // 模块内部异常不拖垮服务面;若响应已开头只能断连(调用方超时语义兜底)
+            if (!res.headersSent) {
+                res.statusCode = 500;
+                res.setHeader('content-type', 'application/json');
+                res.end(JSON.stringify({ error: { code: 'gotry_backend_module_error', module: route ? 'module' : 'kernel' } }));
+            }
+            else {
+                res.destroy();
+            }
+            process.stderr.write(`[gotry-backend] module=${moduleErrorName(options.modules, route)} route=${req.method} ${urlPath} failed: ${error instanceof Error ? error.message : String(error)}\n`);
+        }
+    });
+    return new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(options.port ?? 0, options.host ?? '127.0.0.1', () => {
+            server.off('error', reject);
+            const address = server.address();
+            const port = typeof address === 'object' && address ? address.port : (options.port ?? 0);
+            resolve({
+                server,
+                port,
+                moduleNames: options.modules.map((m) => m.name),
+                close: () => new Promise((done, fail) => server.close((error) => error ? fail(error) : done())),
+            });
+        });
+    });
+}
+function moduleErrorName(modules, route) {
+    if (!route)
+        return 'unknown';
+    for (const m of modules) {
+        if (m.routes.includes(route))
+            return m.name;
+    }
+    return 'unknown';
+}
+/** 关闭全部模块 + 服务面(单模块 close 失败不阻断其余回收,最后聚合抛出) */
+export async function closeBackend(handle, modules) {
+    const errors = [];
+    for (const module of modules) {
+        if (!module.close)
+            continue;
+        try {
+            await module.close();
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    try {
+        await handle.close();
+    }
+    catch (error) {
+        errors.push(error);
+    }
+    if (errors.length > 0)
+        throw new AggregateError(errors, 'gotry_backend_close_failed');
+}

package/dist/src/backend/modules/booking-copilot.js

@@ -0,0 +1,92 @@
+/**
+ * booking-copilot 模块(gotry-backend 的能力单元之一;booking surface 能力)。
+ *
+ * 组装 = startup.ts 同款(ensureLedger → TaskRuntime → dsh planner),路由挂载 =
+ * server.ts 摘出的 bookingCopilotTrafficHandler(与独立部署形态逐字一致:
+ * POST /a2a/booking-copilot/turn + GET /healthz|/status 探活,Bearer apiKey,
+ * schema 头校验)。ingress 固定 bound-turn-only(注入 seam 是部署级组合,本模块不携带)。
+ */
+import { mkdirSync } from 'node:fs';
+import { ensureLedger } from '../../state-ledger.js';
+import { BookingCopilotTaskRuntime } from '../../booking-surface/runtime.js';
+import { buildDshPlannerEnvironment, createDshEmbeddedBookingPlanner, } from '../../booking-surface/dsh-planner.js';
+import { bookingCopilotTrafficHandler, runtimeIdentity, shutdownBookingCopilotTraffic, } from '../../booking-surface/server.js';
+import { resolveBookingCopilotStartupConfig } from '../../booking-surface/startup.js';
+const DEFAULT_DEPENDENCIES = {
+    ensureLedger,
+    createPlanner: createDshEmbeddedBookingPlanner,
+};
+export async function startBookingCopilotModule(env = process.env, dependencies = DEFAULT_DEPENDENCIES) {
+    const config = resolveBookingCopilotStartupConfig(env);
+    mkdirSync(config.stateRoot, { recursive: true });
+    const ledger = dependencies.ensureLedger(config.stateRoot);
+    let planner;
+    try {
+        // The unified gotry-backend mounts this module instead of the standalone
+        // startup, so it has to pass the same planner options: a deadline only the
+        // standalone entry applied is a deadline the serving path never sees.
+        planner = await dependencies.createPlanner({
+            stateRoot: config.stateRoot,
+            env: buildDshPlannerEnvironment(env),
+            ...(config.plannerTurnTimeoutMs === undefined ? {} : { turnTimeoutMs: config.plannerTurnTimeoutMs }),
+        });
+    }
+    catch (error) {
+        try {
+            ledger.close();
+        }
+        catch { /* 聚合首错优先 */ }
+        throw error;
+    }
+    const composition = {
+        runtime: new BookingCopilotTaskRuntime(ledger),
+        plannerFactory: planner.plannerFactory,
+        ingressMode: 'bff-bound-turn-only',
+    };
+    const traffic = bookingCopilotTrafficHandler({
+        apiKey: config.apiKey,
+        composition,
+        maxBodyBytes: 1_000_000,
+        ...(config.artifactId !== undefined ? { artifactId: config.artifactId } : {}),
+        ingressMode: 'bff-bound-turn-only',
+        runningIdentity: runtimeIdentity(),
+    });
+    const respond = (req, res) => traffic(req, res);
+    let closePromise;
+    return {
+        name: 'booking-copilot',
+        routes: [
+            { method: 'POST', path: '/a2a/booking-copilot/turn', handle: respond },
+            { method: 'GET', path: '/healthz', handle: respond },
+            { method: 'GET', path: '/status', handle: respond },
+        ],
+        async close() {
+            if (!closePromise) {
+                closePromise = (async () => {
+                    const failures = [];
+                    try {
+                        await shutdownBookingCopilotTraffic(composition);
+                    }
+                    catch (error) {
+                        failures.push(error);
+                    }
+                    try {
+                        await planner.close();
+                    }
+                    catch (error) {
+                        failures.push(error);
+                    }
+                    try {
+                        ledger.close();
+                    }
+                    catch (error) {
+                        failures.push(error);
+                    }
+                    if (failures.length > 0)
+                        throw new AggregateError(failures, 'booking_copilot_module_close_failed');
+                })();
+            }
+            return closePromise;
+        },
+    };
+}

package/dist/src/backend/modules/booking-executor.js

@@ -0,0 +1,124 @@
+/**
+ * booking-executor 模块(gotry-backend 能力单元;M1 预订链执行面骨架)。
+ *
+ * 红线(设计文档 §7 / WriteGate):
+ *   - 本模块只提供「只读观察 + 截图存证」;填单/提交原语**不存在**——写动作由
+ *     后续确认门放行后的受控执行器实现,当前骨架刻意不建。
+ *   - 观察对象 = dida 页面自己的预订入口(按钮文本与数量),不读取任何凭据/Cookie 值。
+ *
+ * 路由(鉴权:Bearer GOTRY_BACKEND_BOOKING_API_KEY;缺 key = fail-closed 503):
+ *   POST /v1/booking/observe → 打开供应商页面,观察预订入口并截图存证
+ *
+ * 观察器可注入(测试/未来多供应商扩展);缺省实现 = CDP 只读观察
+ * (openSession,ReadGuard 照常生效)。
+ */
+import { mkdirSync } from 'node:fs';
+import { openSession } from '../../../capabilities/session/transport.js';
+function sendJson(res, status, body) {
+    res.statusCode = status;
+    res.setHeader('content-type', 'application/json');
+    res.end(JSON.stringify(body));
+}
+async function readBody(req, cap = 32 * 1024) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        req.on('data', (c) => {
+            size += c.length;
+            if (size > cap) {
+                reject(new Error(`body 超 ${cap} 字节上限`));
+                req.destroy();
+                return;
+            }
+            chunks.push(c);
+        });
+        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        req.on('error', reject);
+    });
+}
+/** 缺省观察器:CDP 打开页面 → 读预订入口按钮 → 截图存证(只读;零提交原语) */
+export async function defaultObserve(req, evidenceDir) {
+    const t = await openSession({ mode: 'cdp', guard: true, newPage: true, closeOwnPage: true });
+    if (!t.ok)
+        throw new Error(`会话主机 Chrome 不可达: ${t.summary}`);
+    try {
+        await t.page.goto(req.entryUrl ?? 'https://portal.dida.com/hotel/find', { waitUntil: 'domcontentloaded', timeout: 30_000 });
+        const entryPoints = (await t.page.evaluate(() => {
+            return Array.from(document.querySelectorAll('button'))
+                .filter((b) => b.textContent != null && b.textContent.includes('预订'))
+                .slice(0, 10)
+                .map((b) => ({ text: (b.textContent ?? '').trim().slice(0, 40), tag: 'button' }));
+        }));
+        mkdirSync(evidenceDir, { recursive: true });
+        const screenshotPath = `${evidenceDir}/observe-${Date.now()}.png`;
+        await t.page.screenshot({ path: screenshotPath });
+        return {
+            ok: true,
+            supplier: req.supplier,
+            entryUrl: req.entryUrl ?? 'https://portal.dida.com/hotel/find',
+            entryPoints,
+            screenshotPath,
+            observedAt: new Date().toISOString(),
+        };
+    }
+    finally {
+        await t.close();
+    }
+}
+export function startBookingExecutorModule(options) {
+    const authorized = (req, res) => {
+        const key = options.apiKey();
+        const auth = String(req.headers.authorization ?? '');
+        if (!key) {
+            sendJson(res, 503, { ok: false, error: 'GOTRY_BACKEND_BOOKING_API_KEY 未配置(fail-closed)' });
+            return false;
+        }
+        if (auth !== `Bearer ${key}`) {
+            sendJson(res, 403, { ok: false, error: 'forbidden' });
+            return false;
+        }
+        return true;
+    };
+    const observe = options.observe ?? (async (req) => defaultObserve(req, '/tmp/booking-evidence'));
+    async function handleObserve(req, res) {
+        let parsed;
+        try {
+            parsed = JSON.parse(await readBody(req));
+        }
+        catch {
+            sendJson(res, 400, { ok: false, error: 'body 不是 JSON' });
+            return;
+        }
+        const supplier = (parsed.supplier ?? '').trim();
+        if (supplier !== 'dida-portal') {
+            sendJson(res, 400, { ok: false, error: `未知供应商通道 ${supplier || '(空)'}` });
+            return;
+        }
+        const entryUrl = (parsed.entryUrl ?? '').trim() || 'https://portal.dida.com/hotel/find';
+        if (!/^https:\/\/portal\.dida\.com\//.test(entryUrl)) {
+            sendJson(res, 400, { ok: false, error: 'entry URL 必须落在 https://portal.dida.com/ 域内' });
+            return;
+        }
+        try {
+            const result = await observe({ supplier, entryUrl });
+            sendJson(res, 200, result);
+        }
+        catch (e) {
+            sendJson(res, 502, { ok: false, error: `观察失败: ${e instanceof Error ? e.message.slice(0, 200) : String(e)}` });
+        }
+    }
+    return {
+        name: 'booking-executor',
+        routes: [
+            {
+                method: 'POST',
+                path: '/v1/booking/observe',
+                handle: (req, res) => {
+                    if (!authorized(req, res))
+                        return;
+                    void handleObserve(req, res);
+                },
+            },
+        ],
+    };
+}