@danceiny/gotry 0.0.1-rc.21 → 0.0.1-rc.24

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

@@ -1,3 +1,10 @@
+/**
+ * BFF-only typed HTTP/SSE seam proof.
+ *
+ * Run with Node 24 from the repository root:
+ *   npx --yes --package=node@24 --package=tsx --call \
+ *     'tsx ts/scripts/booking-copilot-server-proof-tests.ts'
+ */
 import assert from 'node:assert/strict';
 import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
@@ -14,20 +21,19 @@ 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'
+    idFactory: (prefix) => `${prefix}-${++nextId}`,
+    now: () => '2026-08-30T12:00:00.000Z',
 });
 let factoryCalls = 0;
 let sessionTurns = 0;
-const plannerFactory = (initialTask)=>{
+const plannerFactory = (initialTask) => {
     factoryCalls += 1;
     assert.equal(initialTask.taskId, 'task-http-1');
     return {
-        async next ({ task }) {
+        async next({ task }) {
             sessionTurns += 1;
             if (sessionTurns === 1) {
-                return [
-                    {
+                return [{
                         kind: 'operation',
                         action: {
                             schemaVersion: 'booking.surface',
@@ -37,36 +43,28 @@ const plannerFactory = (initialTask)=>{
                             expectedRevision: task.revision,
                             reason: 'Run the authoritative workspace search',
                             factRefs: [],
-                            input: {}
-                        }
-                    }
-                ];
+                            input: {},
+                        },
+                    }];
             }
             return [
                 {
                     kind: 'explanation',
-                    explanation: {
-                        text: '{"kind":"search.run","input":{}}',
-                        factRefs: []
-                    }
+                    explanation: { text: '{"kind":"search.run","input":{}}', factRefs: [] },
                 },
                 {
                     kind: 'terminal',
-                    terminal: {
-                        status: 'completed',
-                        summary: 'Stopped at the requested search result.',
-                        factRefs: []
-                    }
-                }
+                    terminal: { status: 'completed', summary: 'Stopped at the requested search result.', factRefs: [] },
+                },
             ];
-        }
+        },
     };
 };
 const serverHandle = await startBookingCopilotServer({
     apiKey: API_KEY,
     runtime,
     plannerFactory,
-    artifactId: ARTIFACT_ID
+    artifactId: ARTIFACT_ID,
 });
 const endpoint = `http://127.0.0.1:${serverHandle.port}/a2a/booking-copilot/turn`;
 const expectedProbe = {
@@ -74,10 +72,7 @@ const expectedProbe = {
     schemaSha256: SCHEMA_SHA256,
     status: 'ready',
     ingressMode: 'bff-bound-turn-only',
-    acceptedTurnKinds: [
-        'user.turn',
-        'action.receipt.continuation'
-    ]
+    acceptedTurnKinds: ['user.turn', 'action.receipt.continuation'],
 };
 const runtimeReport = process.report?.getReport?.();
 const runtimeGlibcVersion = runtimeReport?.header?.glibcVersionRuntime ?? '';
@@ -86,29 +81,15 @@ await assert.rejects(startBookingCopilotServer({
     apiKey: API_KEY,
     runtime,
     plannerFactory,
-    artifactId: 'not-a-commit'
+    artifactId: 'not-a-commit',
 }), /booking_copilot_artifact_id_invalid/);
-for (const path of [
-    '/healthz',
-    '/status'
-]){
+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);
+    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}`
-        }
-    });
+    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`);
@@ -127,18 +108,14 @@ const workspace = {
     locale: 'zh-CN',
     currency: 'AED',
     searchDraft: {},
-    results: {
-        status: 'idle'
-    },
+    results: { status: 'idle' },
     visibleHotels: [],
     loadedOffers: [],
     shortlistedOfferRefs: [],
     capabilities: {
         surface: 'tenant',
-        allowedActions: [
-            'search.run'
-        ]
-    }
+        allowedActions: ['search.run'],
+    },
 };
 const userTurn = {
     schemaVersion: 'booking.surface',
@@ -146,36 +123,27 @@ const userTurn = {
     taskId: 'task-http-1',
     turnId: 'http-turn-1',
     workspace,
-    request: {
-        text: '执行当前搜索'
-    }
+    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)
-    });
+    '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)
+    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)
+    'x-booking-surface-schema-sha256': '0'.repeat(64),
 });
 assert.equal(wrongSchemaHash.status, 409, 'schema drift is rejected before planning');
 const directIngress = await post({
@@ -184,28 +152,14 @@ const directIngress = await post({
     requestKey: 'browser-request-1',
     surfaceHint: 'tenant',
     workspace: {
-        schemaVersion: 'booking.surface',
-        revision: 0,
-        locale: 'zh-CN',
-        currency: 'AED',
-        searchDraft: {},
-        results: {
-            status: 'idle'
-        },
-        visibleHotels: [],
-        loadedOffers: [],
-        shortlistedOfferRefs: []
+        schemaVersion: 'booking.surface', revision: 0, locale: 'zh-CN', currency: 'AED',
+        searchDraft: {}, results: { status: 'idle' }, visibleHotels: [], loadedOffers: [], shortlistedOfferRefs: [],
     },
-    request: {
-        text: 'browser must use same-origin BFF'
-    }
+    request: { text: 'browser must use same-origin BFF' },
 });
 assert.equal(directIngress.status, 503, 'GoTry server rejects unbound browser ingress');
 assert.equal((await directIngress.json()).error.code, 'trusted_ingress_binding_required');
-const tokenSmuggle = await post({
-    ...userTurn,
-    portalToken: 'ST:must-not-cross-boundary'
-});
+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);
@@ -213,21 +167,16 @@ 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: '));
+    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',
-    'status'
-]);
+assert.deepEqual(firstEvents.map((event) => event.kind), ['status', 'status', 'operation', 'status']);
 assert.equal(firstEvents[3].kind === 'status' ? firstEvents[3].status : '', 'waiting_receipt', 'the operation leaves the task durably waiting for its receipt');
-assert.ok(firstEvents.every((event)=>event.contextRef === workspace.contextRef), 'every typed event carries BFF-minted contextRef');
+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);
@@ -239,11 +188,7 @@ const receiptTurn = {
     workspace: {
         ...workspace,
         revision: 1,
-        results: {
-            status: 'ready',
-            resultCount: 2,
-            searchSessionRef: 'search-http-1'
-        }
+        results: { status: 'ready', resultCount: 2, searchSessionRef: 'search-http-1' },
     },
     receipt: {
         schemaVersion: 'booking.surface',
@@ -252,37 +197,22 @@ const receiptTurn = {
         contextRef: workspace.contextRef,
         status: 'applied',
         revision: 1,
-        observation: {
-            kind: 'search.state',
-            searchSessionRef: 'search-http-1',
-            resultCount: 2
-        },
-        resultContract: {
-            outcome: 'complete',
-            hardCriteriaMet: true,
-            factRefs: [],
-            gapCodes: [],
-            blockers: [],
-            relaxationsApplied: []
-        }
-    }
+        observation: { kind: 'search.state', searchSessionRef: 'search-http-1', resultCount: 2 },
+        resultContract: { outcome: 'complete', hardCriteriaMet: true, factRefs: [], gapCodes: [], blockers: [], relaxationsApplied: [] },
+    },
 };
 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.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.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();
 const preRestartRuntime = new BookingCopilotTaskRuntime(ledger, {
-    idFactory: (prefix)=>`${prefix}-probe-${++nextId}`,
-    now: ()=>'2026-08-30T12:01:00.000Z'
+    idFactory: (prefix) => `${prefix}-probe-${++nextId}`,
+    now: () => '2026-08-30T12:01:00.000Z',
 });
 const recovered = preRestartRuntime.resumeTask('task-http-1');
 assert.equal(recovered?.lastReceipt?.actionId, 'action-http-1', 'new server process seam restores task from last typed receipt');
@@ -290,23 +220,10 @@ assert.equal(recovered?.phase, 'terminal', 'the completed task stays durably ter
 const restarted = await startBookingCopilotServer({
     apiKey: API_KEY,
     runtime: preRestartRuntime,
-    plannerFactory: (initialTask)=>{
+    plannerFactory: (initialTask) => {
         assert.equal(initialTask.taskId, 'task-http-2');
-        return {
-            async next () {
-                return [
-                    {
-                        kind: 'terminal',
-                        terminal: {
-                            status: 'stopped',
-                            summary: 'Recovered.',
-                            factRefs: []
-                        }
-                    }
-                ];
-            }
-        };
-    }
+        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, {
@@ -316,37 +233,15 @@ const afterRestartResponse = await fetch(restartedEndpoint, {
         'content-type': 'application/json',
         accept: 'text/event-stream',
         'x-booking-surface-version': SCHEMA_VERSION,
-        'x-booking-surface-schema-sha256': SCHEMA_SHA256
+        'x-booking-surface-schema-sha256': SCHEMA_SHA256,
     },
-    body: JSON.stringify({
-        ...userTurn,
-        taskId: 'task-http-2',
-        turnId: 'http-restart-turn-1',
-        workspace: {
-            ...workspace,
-            contextRef: 'ctx-http-2'
-        }
-    })
+    body: JSON.stringify({ ...userTurn, taskId: 'task-http-2', turnId: 'http-restart-turn-1', workspace: { ...workspace, contextRef: 'ctx-http-2' } }),
 });
 assert.equal(afterRestartResponse.status, 200);
 const restartEvents = parseSse(await afterRestartResponse.text());
-assert.deepEqual(restartEvents.map((event)=>event.kind), [
-    'status',
-    'status',
-    'terminal'
-]);
-assert.deepEqual(restartEvents.map((event)=>event.sequence), [
-    1,
-    2,
-    3
-], 'the restarted process allocates fresh task-scoped sequences after recovering the ledger');
+assert.deepEqual(restartEvents.map((event) => event.kind), ['status', 'status', 'terminal']);
+assert.deepEqual(restartEvents.map((event) => event.sequence), [1, 2, 3], 'the restarted process allocates fresh task-scoped sequences after recovering the ledger');
 await restarted.close();
 ledger.close();
-rmSync(stateRoot, {
-    recursive: true,
-    force: true
-});
+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

@@ -1,19 +1,20 @@
+/** Production startup composition proof (dependencies injected; no real model). */
 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 { resolveBookingCopilotStartupConfig, startBookingCopilotFromEnvironment, } from '../src/booking-surface/startup.js';
 import { BOOKING_READ_ACTION_KINDS } from '../src/booking-surface/contracts.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/);
+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',
@@ -22,134 +23,57 @@ const env = {
     GOTRY_BOOKING_COPILOT_ARTIFACT_ID: '1111111111111111111111111111111111111111',
     LLM_API_KEY: 'model-only-key',
     PORTAL_TOKEN: 'must-not-enter-planner',
-    HOTELBYTE_TOKEN: 'must-not-enter-planner'
+    HOTELBYTE_TOKEN: 'must-not-enter-planner',
 };
-await assert.rejects(startBookingCopilotFromEnvironment({
-    ...env,
-    GOTRY_BOOKING_COPILOT_INGRESS_MODE: 'bff-ingress-binding'
-}, {}), /booking_copilot_ingress_binding_required/, 'explicit ingress mode rejects startup when the trusted BFF seam is absent');
+await assert.rejects(startBookingCopilotFromEnvironment({ ...env, GOTRY_BOOKING_COPILOT_INGRESS_MODE: 'bff-ingress-binding' }, {}), /booking_copilot_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
-                ]
-            })
-    }
+    ingressBinding: { bind: () => ({ taskId: 'partial-task', turnId: 'partial-turn', contextRef: 'partial-context', surface: 'tenant', allowedActions: [...BOOKING_READ_ACTION_KINDS] }) },
 }), /booking_copilot_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_ingress_binding_pair_required/, 'principal without a binding is rejected before startup');
+await assert.rejects(startBookingCopilotFromEnvironment(env, { principal: { subject: 'partial-bff', scope: 'booking:read' } }), /booking_copilot_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 () {}
-        }),
-    async startServer (options) {
+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() { } }),
+    async startServer(options) {
         standaloneIngressMode = options.ingressMode ?? '';
-        return {
-            server: {},
-            port: 43122,
-            async close () {}
-        };
-    }
+        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
-});
+rmSync(standaloneStateRoot, { recursive: true, force: true });
 const closeOrder = [];
 let plannerEnv;
 let serverApiKey = '';
 let serverArtifactId = '';
-const trustedEnv = {
-    ...env,
-    GOTRY_BOOKING_COPILOT_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
-            ]
-        })
-};
+const trustedEnv = { ...env, GOTRY_BOOKING_COPILOT_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] }) };
 const started = await startBookingCopilotFromEnvironment(trustedEnv, {
-    ensureLedger () {
-        return fakeLedger;
-    },
-    runtimeFactory () {
-        return {};
-    },
-    async createPlanner (options) {
+    ensureLedger() { return fakeLedger; },
+    runtimeFactory() { return {}; },
+    async createPlanner(options) {
         plannerEnv = options.env;
         return {
-            plannerFactory () {
-                return {
-                    async next () {
-                        return [];
-                    }
-                };
-            },
-            async close () {
-                closeOrder.push('planner');
-            }
+            plannerFactory() { return { async next() { return []; } }; },
+            async close() { closeOrder.push('planner'); },
         };
     },
     ingressBinding: trustedBinding,
-    principal: {
-        subject: 'startup-bff',
-        scope: 'booking:read'
-    },
-    async startServer (options) {
+    principal: { subject: 'startup-bff', scope: 'booking:read' },
+    async startServer(options) {
         serverApiKey = options.apiKey;
         serverArtifactId = options.artifactId ?? '';
         assert.equal(options.ingressMode, 'bff-ingress-binding');
         return {
             server: {},
             port: 43123,
-            async close () {
-                closeOrder.push('server');
-            }
+            async close() { closeOrder.push('server'); },
         };
-    }
+    },
 });
 assert.equal(started.port, 43123);
 assert.equal(serverApiKey, 'bff-only-key', 'BFF deployment key terminates at the HTTP server');
@@ -159,16 +83,6 @@ assert.equal(plannerEnv?.GOTRY_BOOKING_COPILOT_API_KEY, undefined);
 assert.equal(plannerEnv?.PORTAL_TOKEN, undefined);
 assert.equal(plannerEnv?.HOTELBYTE_TOKEN, undefined);
 await started.close();
-assert.deepEqual(closeOrder, [
-    'server',
-    'planner',
-    'ledger'
-]);
-rmSync(stateRoot, {
-    recursive: true,
-    force: true
-});
+assert.deepEqual(closeOrder, ['server', 'planner', 'ledger']);
+rmSync(stateRoot, { 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

package/dist/scripts/booking-executor-tests.js

@@ -0,0 +1,80 @@
+import { closeBackend, createBackendServer } from '../src/backend/kernel.js';
+import { startBookingExecutorModule } from '../src/backend/modules/booking-executor.js';
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+let pass = 0;
+let fail = 0;
+const check = (cond, label) => {
+    if (cond) {
+        pass += 1;
+        console.log(`  ok - ${label}`);
+    }
+    else {
+        fail += 1;
+        console.log(`  FAIL - ${label}`);
+    }
+};
+async function jfetch(url, init) {
+    const r = await fetch(url, init);
+    let body = null;
+    try {
+        body = await r.json();
+    }
+    catch { /* 空体 */ }
+    return { status: r.status, body };
+}
+async function main() {
+    const module = startBookingExecutorModule({
+        apiKey: () => 'test-booking-key',
+        evidenceDir: () => '/tmp/booking-executor-test-evidence',
+        observe: async () => ({
+            ok: true,
+            supplier: 'dida-portal',
+            entryUrl: 'https://portal.dida.com/hotel/find',
+            entryPoints: [{ text: '预订', tag: 'button' }],
+            screenshotPath: '/tmp/evidence/test.png',
+            observedAt: new Date().toISOString(),
+        }),
+    });
+    const handle = await createBackendServer({ modules: [module], port: 0 });
+    const base = `http://127.0.0.1:${handle.port}`;
+    try {
+        // ① 鉴权 fail-closed
+        const noAuth = await jfetch(`${base}/v1/booking/observe`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ supplier: 'dida-portal' }),
+        });
+        check(noAuth.status === 403, '无 token 403');
+        // ② 注入观察器:正常观察
+        const ok = await jfetch(`${base}/v1/booking/observe`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json', authorization: 'Bearer test-booking-key' },
+            body: JSON.stringify({ supplier: 'dida-portal' }),
+        });
+        const okBody = ok.body;
+        check(ok.status === 200 && okBody.ok === true && okBody.supplier === 'dida-portal', '观察返回 200 + 供应商');
+        check(Array.isArray(okBody.entryPoints) && okBody.entryPoints.length === 1, '入口观察条目形状');
+        // ③ 未知供应商拒绝
+        const bad = await jfetch(`${base}/v1/booking/observe`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json', authorization: 'Bearer test-booking-key' },
+            body: JSON.stringify({ supplier: 'ctrip-flight' }),
+        });
+        check(bad.status === 400, '未知供应商 400');
+        // ④ 域外 entryUrl 拒绝
+        const evil = await jfetch(`${base}/v1/booking/observe`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json', authorization: 'Bearer test-booking-key' },
+            body: JSON.stringify({ supplier: 'dida-portal', entryUrl: 'https://evil.example.com/x' }),
+        });
+        check(evil.status === 400, '域外 entryUrl 400');
+    }
+    finally {
+        await closeBackend(handle, [module]).catch(() => { });
+    }
+    await sleep(30);
+    console.log(`\nBOOKING EXECUTOR: ${pass} pass, ${fail} fail`);
+    if (fail > 0)
+        process.exitCode = 1;
+}
+void main();