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

package/dist/scripts/booking-copilot-server-proof-tests.js

@@ -0,0 +1,317 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { ensureLedger } from '../src/state-ledger.js';
+import { BookingCopilotTaskRuntime } from '../src/booking-surface/runtime.js';
+import { startBookingCopilotServer } from '../src/booking-surface/server.js';
+import { BOOKING_SURFACE_SCHEMA_SHA256, BOOKING_SURFACE_SCHEMA_VERSION } from '../src/booking-surface/contracts.js';
+const API_KEY = 'server-to-server-key';
+const SCHEMA_VERSION = BOOKING_SURFACE_SCHEMA_VERSION;
+const SCHEMA_SHA256 = BOOKING_SURFACE_SCHEMA_SHA256;
+const ARTIFACT_ID = '1111111111111111111111111111111111111111';
+const stateRoot = mkdtempSync(join(tmpdir(), 'gotry-booking-server-'));
+const ledger = ensureLedger(stateRoot);
+let nextId = 0;
+const runtime = new BookingCopilotTaskRuntime(ledger, {
+    idFactory: (prefix)=>`${prefix}-${++nextId}`,
+    now: ()=>'2026-08-30T12:00:00.000Z'
+});
+let factoryCalls = 0;
+let sessionTurns = 0;
+const plannerFactory = (initialTask)=>{
+    factoryCalls += 1;
+    assert.equal(initialTask.taskId, 'task-http-1');
+    return {
+        async next ({ task }) {
+            sessionTurns += 1;
+            if (sessionTurns === 1) {
+                return [
+                    {
+                        kind: 'operation',
+                        action: {
+                            schemaVersion: 'booking.surface.v1',
+                            kind: 'search.run',
+                            actionId: 'action-http-1',
+                            contextRef: task.contextRef,
+                            expectedRevision: task.revision,
+                            reason: 'Run the authoritative workspace search',
+                            factRefs: [],
+                            input: {}
+                        }
+                    }
+                ];
+            }
+            return [
+                {
+                    kind: 'explanation',
+                    explanation: {
+                        text: '{"kind":"search.run","input":{}}',
+                        factRefs: []
+                    }
+                },
+                {
+                    kind: 'terminal',
+                    terminal: {
+                        status: 'completed',
+                        summary: 'Stopped at the requested search result.',
+                        factRefs: []
+                    }
+                }
+            ];
+        }
+    };
+};
+const serverHandle = await startBookingCopilotServer({
+    apiKey: API_KEY,
+    runtime,
+    plannerFactory,
+    artifactId: ARTIFACT_ID
+});
+const endpoint = `http://127.0.0.1:${serverHandle.port}/a2a/booking-copilot/turn`;
+const expectedProbe = {
+    schemaVersion: SCHEMA_VERSION,
+    schemaSha256: SCHEMA_SHA256,
+    status: 'ready'
+};
+const runtimeReport = process.report?.getReport?.();
+const runtimeGlibcVersion = runtimeReport?.header?.glibcVersionRuntime ?? '';
+const runtimeReleaseTuple = `${process.platform}-${process.arch}-${runtimeGlibcVersion ? 'glibc' : 'unknown'}`;
+await assert.rejects(startBookingCopilotServer({
+    apiKey: API_KEY,
+    runtime,
+    plannerFactory,
+    artifactId: 'not-a-commit'
+}), /booking_copilot_artifact_id_invalid/);
+for (const path of [
+    '/healthz',
+    '/status'
+]){
+    const probeUrl = `http://127.0.0.1:${serverHandle.port}${path}`;
+    for (const authorization of [
+        undefined,
+        'Bearer wrong-key'
+    ]){
+        const rejected = await fetch(probeUrl, authorization ? {
+            headers: {
+                authorization
+            }
+        } : undefined);
+        assert.equal(rejected.status, 401, `${path} rejects ${authorization ? 'wrong' : 'missing'} bearer`);
+    }
+    const authorized = await fetch(probeUrl, {
+        headers: {
+            authorization: `Bearer ${API_KEY}`
+        }
+    });
+    assert.equal(authorized.status, 200, `${path} accepts deployment bearer`);
+    assert.equal(authorized.headers.get('x-booking-surface-version'), SCHEMA_VERSION, `${path} returns canonical schema version header`);
+    assert.equal(authorized.headers.get('x-booking-surface-schema-sha256'), SCHEMA_SHA256, `${path} returns canonical schema hash header`);
+    assert.equal(authorized.headers.get('x-gotry-artifact-id'), ARTIFACT_ID, `${path} returns the running release identity`);
+    assert.equal(authorized.headers.get('x-gotry-node-version'), process.version, `${path} returns the actual Node runtime`);
+    assert.equal(authorized.headers.get('x-gotry-node-modules-abi'), process.versions.modules, `${path} returns the actual native ABI`);
+    assert.equal(authorized.headers.get('x-gotry-release-tuple'), runtimeReleaseTuple, `${path} returns the actual runtime tuple`);
+    assert.equal(authorized.headers.get('x-gotry-glibc-version'), runtimeGlibcVersion || null, `${path} returns glibc only when present`);
+    assert.deepEqual(await authorized.json(), expectedProbe, `${path} exposes only typed readiness contract`);
+}
+const workspace = {
+    schemaVersion: 'booking.surface.v1',
+    contextRef: 'ctx-http-1',
+    surface: 'tenant',
+    revision: 0,
+    locale: 'zh-CN',
+    currency: 'AED',
+    searchDraft: {},
+    results: {
+        status: 'idle'
+    },
+    visibleHotels: [],
+    loadedOffers: [],
+    shortlistedOfferRefs: [],
+    capabilities: {
+        surface: 'tenant',
+        allowedActions: [
+            'search.run'
+        ]
+    }
+};
+const userTurn = {
+    schemaVersion: 'booking.surface.v1',
+    kind: 'user.turn',
+    taskId: 'task-http-1',
+    workspace,
+    request: {
+        text: '执行当前搜索'
+    }
+};
+const post = (body, authorization = `Bearer ${API_KEY}`, schemaHeaders = {
+    'x-booking-surface-version': SCHEMA_VERSION,
+    'x-booking-surface-schema-sha256': SCHEMA_SHA256
+})=>fetch(endpoint, {
+        method: 'POST',
+        headers: {
+            authorization,
+            'content-type': 'application/json',
+            accept: 'text/event-stream',
+            ...schemaHeaders
+        },
+        body: JSON.stringify(body)
+    });
+const noAuth = await fetch(endpoint, {
+    method: 'POST',
+    headers: {
+        'content-type': 'application/json'
+    },
+    body: JSON.stringify(userTurn)
+});
+assert.equal(noAuth.status, 401, 'server-to-server key is fail-closed');
+const missingSchemaHeaders = await post(userTurn, `Bearer ${API_KEY}`, {});
+assert.equal(missingSchemaHeaders.status, 409, 'schema version/hash headers are required');
+const wrongSchemaHash = await post(userTurn, `Bearer ${API_KEY}`, {
+    'x-booking-surface-version': SCHEMA_VERSION,
+    'x-booking-surface-schema-sha256': '0'.repeat(64)
+});
+assert.equal(wrongSchemaHash.status, 409, 'schema drift is rejected before planning');
+const directIngress = await post({
+    schemaVersion: 'booking.surface.v1',
+    kind: 'user.turn.ingress',
+    surfaceHint: 'tenant',
+    workspace: {
+        ...workspace,
+        contextRef: undefined,
+        surface: undefined,
+        capabilities: undefined
+    },
+    request: {
+        text: 'browser must use same-origin BFF'
+    }
+});
+assert.equal(directIngress.status, 400, 'GoTry server rejects unbound browser ingress');
+const tokenSmuggle = await post({
+    ...userTurn,
+    portalToken: 'ST:must-not-cross-boundary'
+});
+assert.equal(tokenSmuggle.status, 400, 'strict planner turn rejects portal token fields');
+const first = await post(userTurn);
+assert.equal(first.status, 200);
+assert.match(String(first.headers.get('content-type')), /text\/event-stream/);
+assert.equal(first.headers.get('x-booking-surface-version'), SCHEMA_VERSION);
+assert.equal(first.headers.get('x-booking-surface-schema-sha256'), SCHEMA_SHA256);
+function parseSse(body) {
+    return body.trim().split('\n\n').map((frame)=>{
+        const data = frame.split('\n').find((line)=>line.startsWith('data: '));
+        assert.ok(data, `SSE frame has data: ${frame}`);
+        return JSON.parse(data.slice('data: '.length));
+    });
+}
+const firstEvents = parseSse(await first.text());
+assert.deepEqual(firstEvents.map((event)=>event.kind), [
+    'status',
+    'status',
+    'operation'
+]);
+assert.ok(firstEvents.every((event)=>event.contextRef === workspace.contextRef), 'every typed event carries BFF-minted contextRef');
+const operation = firstEvents[2];
+assert.equal(operation?.kind, 'operation');
+assert.equal(factoryCalls, 1);
+assert.equal(sessionTurns, 1);
+const receiptTurn = {
+    schemaVersion: 'booking.surface.v1',
+    kind: 'action.receipt.continuation',
+    taskId: 'task-http-1',
+    workspace: {
+        ...workspace,
+        revision: 1,
+        results: {
+            status: 'ready',
+            resultCount: 2,
+            searchSessionRef: 'search-http-1'
+        }
+    },
+    receipt: {
+        schemaVersion: 'booking.surface.v1',
+        kind: 'action.receipt',
+        actionId: 'action-http-1',
+        contextRef: workspace.contextRef,
+        status: 'applied',
+        revision: 1,
+        observation: {
+            kind: 'search.state',
+            searchSessionRef: 'search-http-1',
+            resultCount: 2
+        },
+        resultContract: {
+            outcome: 'complete',
+            hardCriteriaMet: true,
+            factRefs: [],
+            gapCodes: []
+        }
+    }
+};
+const second = await post(receiptTurn);
+assert.equal(second.status, 200);
+const secondEvents = parseSse(await second.text());
+assert.deepEqual(secondEvents.map((event)=>event.kind), [
+    'status',
+    'explanation',
+    'terminal'
+]);
+assert.equal(factoryCalls, 1, 'one task reuses one planner session across receipt continuations');
+assert.equal(sessionTurns, 2);
+assert.ok(!secondEvents.some((event)=>event.kind === 'operation'), 'JSON-looking explanation text is not parsed into an operation');
+assert.ok(secondEvents[0].sequence > firstEvents.at(-1).sequence, 'SSE sequence is monotonic across turns');
+await serverHandle.close();
+let recoveredLastReceipt = false;
+const restarted = await startBookingCopilotServer({
+    apiKey: API_KEY,
+    runtime: new BookingCopilotTaskRuntime(ledger, {
+        idFactory: (prefix)=>`${prefix}-restart-${++nextId}`,
+        now: ()=>'2026-08-30T12:01:00.000Z'
+    }),
+    plannerFactory: (initialTask)=>{
+        recoveredLastReceipt = initialTask.lastReceipt?.actionId === 'action-http-1';
+        return {
+            async next () {
+                return [
+                    {
+                        kind: 'terminal',
+                        terminal: {
+                            status: 'stopped',
+                            summary: 'Recovered.',
+                            factRefs: []
+                        }
+                    }
+                ];
+            }
+        };
+    }
+});
+const restartedEndpoint = `http://127.0.0.1:${restarted.port}/a2a/booking-copilot/turn`;
+const afterRestartResponse = await fetch(restartedEndpoint, {
+    method: 'POST',
+    headers: {
+        authorization: `Bearer ${API_KEY}`,
+        'content-type': 'application/json',
+        accept: 'text/event-stream',
+        'x-booking-surface-version': SCHEMA_VERSION,
+        'x-booking-surface-schema-sha256': SCHEMA_SHA256
+    },
+    body: JSON.stringify({
+        ...userTurn,
+        workspace: receiptTurn.workspace
+    })
+});
+assert.equal(afterRestartResponse.status, 200);
+assert.equal(recoveredLastReceipt, true, 'new server process seam restores task from last typed receipt');
+const restartEvents = parseSse(await afterRestartResponse.text());
+assert.ok(restartEvents[0].sequence > secondEvents.at(-1).sequence, 'sequence resumes from durable ledger after server restart');
+await restarted.close();
+ledger.close();
+rmSync(stateRoot, {
+    recursive: true,
+    force: true
+});
+console.log('BOOKING COPILOT SERVER PROOF: BFF auth/typed SSE/task session/restart/no-token/no-text-action OK');
+
+
+//# sourceURL=ts/scripts/booking-copilot-server-proof-tests.ts

package/dist/scripts/booking-copilot-startup-proof-tests.js

@@ -0,0 +1,283 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { resolveBookingCopilotStartupConfig, startBookingCopilotFromEnvironment } from '../src/booking-surface/startup.js';
+import { BOOKING_READ_ACTION_KINDS_V2 } from '../src/booking-surface/contracts-v2.js';
+assert.throws(()=>resolveBookingCopilotStartupConfig({}), /booking_copilot_api_key_required/);
+assert.throws(()=>resolveBookingCopilotStartupConfig({
+        GOTRY_BOOKING_COPILOT_API_KEY: 'bff-key',
+        GOTRY_BOOKING_COPILOT_STATE_ROOT: '/tmp/gotry-booking-startup',
+        GOTRY_BOOKING_COPILOT_ARTIFACT_ID: 'not-a-commit'
+    }), /booking_copilot_artifact_id_invalid/);
+assert.throws(()=>resolveBookingCopilotStartupConfig({
+        GOTRY_BOOKING_COPILOT_API_KEY: 'bff-key',
+        GOTRY_BOOKING_COPILOT_STATE_ROOT: 'relative/state'
+    }), /booking_copilot_state_root_must_be_absolute/);
+const stateRoot = mkdtempSync(join(tmpdir(), 'gotry-booking-startup-'));
+const env = {
+    GOTRY_BOOKING_COPILOT_API_KEY: 'bff-only-key',
+    GOTRY_BOOKING_COPILOT_STATE_ROOT: stateRoot,
+    GOTRY_BOOKING_COPILOT_PORT: '0',
+    GOTRY_BOOKING_COPILOT_ARTIFACT_ID: '1111111111111111111111111111111111111111',
+    LLM_API_KEY: 'model-only-key',
+    PORTAL_TOKEN: 'must-not-enter-planner',
+    HOTELBYTE_TOKEN: 'must-not-enter-planner'
+};
+await assert.rejects(startBookingCopilotFromEnvironment({
+    ...env,
+    GOTRY_BOOKING_COPILOT_V2_INGRESS_MODE: 'bff-ingress-binding'
+}, {}), /booking_copilot_v2_ingress_binding_required/, 'explicit ingress mode rejects startup when the trusted BFF seam is absent');
+await assert.rejects(startBookingCopilotFromEnvironment(env, {
+    ingressBinding: {
+        bind: ()=>({
+                taskId: 'partial-task',
+                turnId: 'partial-turn',
+                contextRef: 'partial-context',
+                surface: 'tenant',
+                allowedActions: [
+                    ...BOOKING_READ_ACTION_KINDS_V2
+                ]
+            })
+    }
+}), /booking_copilot_v2_ingress_binding_pair_required/, 'partial trusted BFF seam is rejected before startup');
+await assert.rejects(startBookingCopilotFromEnvironment(env, {
+    principal: {
+        subject: 'partial-bff',
+        scope: 'booking:read'
+    }
+}), /booking_copilot_v2_ingress_binding_pair_required/, 'principal without a binding is rejected before startup');
+let standaloneIngressMode = '';
+const standaloneStateRoot = mkdtempSync(join(tmpdir(), 'gotry-booking-startup-standalone-'));
+const standalone = await startBookingCopilotFromEnvironment({
+    ...env,
+    GOTRY_BOOKING_COPILOT_STATE_ROOT: standaloneStateRoot
+}, {
+    ensureLedger () {
+        return {
+            close () {}
+        };
+    },
+    runtimeFactory () {
+        return {};
+    },
+    createPlanner: async ()=>({
+            plannerFactory () {
+                return {
+                    async next () {
+                        return [];
+                    }
+                };
+            },
+            async close () {}
+        }),
+    runtimeFactoryV2 () {
+        return {};
+    },
+    createPlannerV2: async ()=>({
+            plannerFactory () {
+                return {
+                    async next () {
+                        return [];
+                    }
+                };
+            },
+            async close () {}
+        }),
+    async startServer (options) {
+        standaloneIngressMode = options.v2?.ingressMode ?? '';
+        return {
+            server: {},
+            port: 43122,
+            async close () {}
+        };
+    }
+});
+assert.equal(standalone.port, 43122);
+assert.equal(standaloneIngressMode, 'bff-bound-turn-only', 'standalone production startup uses the explicit bound-turn-only mode');
+await standalone.close();
+rmSync(standaloneStateRoot, {
+    recursive: true,
+    force: true
+});
+const closeOrder = [];
+let plannerEnv;
+let plannerV2Env;
+let serverApiKey = '';
+let serverArtifactId = '';
+const trustedEnv = {
+    ...env,
+    GOTRY_BOOKING_COPILOT_V2_INGRESS_MODE: 'bff-ingress-binding'
+};
+const fakeLedger = {
+    close () {
+        closeOrder.push('ledger');
+    }
+};
+const trustedBinding = {
+    bind: ()=>({
+            taskId: 'startup-task',
+            turnId: 'startup-turn',
+            contextRef: 'startup-context',
+            surface: 'tenant',
+            allowedActions: [
+                ...BOOKING_READ_ACTION_KINDS_V2
+            ]
+        })
+};
+const started = await startBookingCopilotFromEnvironment(trustedEnv, {
+    ensureLedger () {
+        return fakeLedger;
+    },
+    runtimeFactory () {
+        return {};
+    },
+    async createPlanner (options) {
+        plannerEnv = options.env;
+        return {
+            plannerFactory () {
+                return {
+                    async next () {
+                        return [];
+                    }
+                };
+            },
+            async close () {
+                closeOrder.push('planner');
+            }
+        };
+    },
+    runtimeFactoryV2 () {
+        return {};
+    },
+    async createPlannerV2 (options) {
+        plannerV2Env = options.env;
+        return {
+            plannerFactory () {
+                return {
+                    async next () {
+                        return [];
+                    }
+                };
+            },
+            async close () {
+                closeOrder.push('planner-v2');
+            }
+        };
+    },
+    ingressBinding: trustedBinding,
+    principal: {
+        subject: 'startup-bff',
+        scope: 'booking:read'
+    },
+    async startServer (options) {
+        serverApiKey = options.apiKey;
+        serverArtifactId = options.artifactId ?? '';
+        assert.equal(options.v2?.ingressMode, 'bff-ingress-binding');
+        return {
+            server: {},
+            port: 43123,
+            async close () {
+                closeOrder.push('server');
+            }
+        };
+    }
+});
+assert.equal(started.port, 43123);
+assert.equal(serverApiKey, 'bff-only-key', 'BFF deployment key terminates at the HTTP server');
+assert.equal(serverArtifactId, env.GOTRY_BOOKING_COPILOT_ARTIFACT_ID);
+assert.equal(plannerEnv?.DEEPSEEK_API_KEY, 'model-only-key');
+assert.equal(plannerEnv?.GOTRY_BOOKING_COPILOT_API_KEY, undefined);
+assert.equal(plannerEnv?.PORTAL_TOKEN, undefined);
+assert.equal(plannerEnv?.HOTELBYTE_TOKEN, undefined);
+assert.equal(plannerV2Env?.DEEPSEEK_API_KEY, 'model-only-key');
+await started.close();
+assert.deepEqual(closeOrder, [
+    'server',
+    'planner',
+    'planner-v2',
+    'ledger'
+]);
+rmSync(stateRoot, {
+    recursive: true,
+    force: true
+});
+const v2StateRoot = mkdtempSync(join(tmpdir(), 'gotry-booking-startup-v2-'));
+let v2Passed = false;
+let v2PlannerEnv;
+const v2CloseOrder = [];
+const v2Started = await startBookingCopilotFromEnvironment({
+    ...trustedEnv,
+    GOTRY_BOOKING_COPILOT_STATE_ROOT: v2StateRoot
+}, {
+    ensureLedger () {
+        return {
+            close () {
+                v2CloseOrder.push('ledger');
+            }
+        };
+    },
+    runtimeFactory () {
+        return {};
+    },
+    createPlanner: async ()=>({
+            plannerFactory () {
+                return {
+                    async next () {
+                        return [];
+                    }
+                };
+            },
+            async close () {}
+        }),
+    runtimeFactoryV2 () {
+        return {};
+    },
+    async createPlannerV2 (options) {
+        v2PlannerEnv = options.env;
+        return {
+            plannerFactory () {
+                return {
+                    async next () {
+                        return [];
+                    }
+                };
+            },
+            async close () {
+                v2CloseOrder.push('planner-v2');
+            }
+        };
+    },
+    ingressBinding: trustedBinding,
+    principal: {
+        subject: 'startup-bff',
+        scope: 'booking:read'
+    },
+    async startServer (options) {
+        v2Passed = Boolean(options.v2 && options.runtime && options.plannerFactory);
+        return {
+            server: {},
+            port: 43124,
+            async close () {
+                v2CloseOrder.push('server');
+            }
+        };
+    }
+});
+assert.equal(v2Started.port, 43124);
+assert.equal(v2Passed, true, 'v2 startup constructs and passes the real v2 adapter seam');
+assert.equal(v2PlannerEnv?.DEEPSEEK_API_KEY, 'model-only-key');
+await v2Started.close();
+assert.deepEqual(v2CloseOrder, [
+    'server',
+    'planner-v2',
+    'ledger'
+]);
+rmSync(v2StateRoot, {
+    recursive: true,
+    force: true
+});
+console.log('BOOKING COPILOT STARTUP PROOF: env split/server+planner+ledger lifecycle OK');
+
+
+//# sourceURL=ts/scripts/booking-copilot-startup-proof-tests.ts