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

package/dist/scripts/booking-copilot-dsh-planner-proof-tests.js

@@ -1,4 +1,5 @@
 import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
 import { DSH_EMBEDDED_BOOKING_TOOL_NAMES, buildDshPlannerEnvironment, createDshEmbeddedBookingPlanner } from '../src/booking-surface/dsh-planner.js';
 const availability = {
     initialized: true,
@@ -343,7 +344,8 @@ const sanitizedRefPort = {
                                 action: {
                                     ...searchRun,
                                     factRefs: [
-                                        'draft:destination=Dubai'
+                                        'draft:destination=Dubai',
+                                        'draft:destination.Dubai'
                                     ]
                                 }
                             }
@@ -373,9 +375,216 @@ const sanitizedDecisions = await sanitizedRef.plannerFactory(task).next({
 });
 assert.equal(sanitizedDecisions[0]?.kind, 'operation', 'sanitizer maps off-charset characters deterministically');
 assert.deepEqual(sanitizedDecisions[0].action?.factRefs, [
+    'modelref:43b07dd7fc80f4a9889b6c672c450a911086293cab2ef4058b95b53559a2d100',
     'draft:destination.Dubai'
 ]);
 await sanitizedRef.close();
+const collisionRawRefs = [
+    'fact://a/b',
+    'fact:..a?b'
+];
+const collisionResults = [];
+for (const [index, rawRef] of collisionRawRefs.entries()){
+    const collisionPlanner = await createDshEmbeddedBookingPlanner({
+        runPort: {
+            async run () {
+                return {
+                    finalResponse: '',
+                    events: [
+                        {
+                            type: 'tool/call',
+                            data: {
+                                name: 'booking_search_hotels',
+                                arguments: JSON.stringify({
+                                    decision: {
+                                        kind: 'operation',
+                                        action: {
+                                            ...searchRun,
+                                            actionId: `action-dsh-collision-${index}`,
+                                            factRefs: [
+                                                rawRef
+                                            ]
+                                        }
+                                    }
+                                })
+                            }
+                        }
+                    ]
+                };
+            },
+            async close () {}
+        }
+    });
+    const decisions = await collisionPlanner.plannerFactory(task).next({
+        task,
+        turn: {
+            schemaVersion: 'booking.surface',
+            kind: 'user.turn',
+            taskId: task.taskId,
+            turnId: `dsh-collision-${index}`,
+            workspace,
+            request: {
+                text: 'Find hotels'
+            }
+        }
+    });
+    const ref = decisions[0].action?.factRefs?.[0];
+    assert.match(ref ?? '', /^[A-Za-z0-9][A-Za-z0-9:._-]*$/, 'unsafe refs map to the runtime-safe pattern');
+    collisionResults.push(ref ?? '');
+    await collisionPlanner.close();
+}
+assert.notEqual(collisionResults[0], collisionResults[1], 'distinct unsafe raw refs retain collision-resistant aliases');
+assert.equal(collisionRawRefs[0].replace(/#/g, ':').replace(/[^A-Za-z0-9:._-]/g, '.'), collisionRawRefs[1].replace(/#/g, ':').replace(/[^A-Za-z0-9:._-]/g, '.'), 'the collision pair shares the legacy readable projection');
+async function assertFactRefsRejected(factRefs, message) {
+    const planner = await createDshEmbeddedBookingPlanner({
+        runPort: {
+            async run () {
+                return {
+                    finalResponse: '',
+                    events: [
+                        {
+                            type: 'tool/call',
+                            data: {
+                                name: 'booking_search_hotels',
+                                arguments: JSON.stringify({
+                                    decision: {
+                                        kind: 'operation',
+                                        action: {
+                                            ...searchRun,
+                                            factRefs
+                                        }
+                                    }
+                                })
+                            }
+                        }
+                    ]
+                };
+            },
+            async close () {}
+        }
+    });
+    await assert.rejects(planner.plannerFactory(task).next({
+        task,
+        turn: {
+            schemaVersion: 'booking.surface',
+            kind: 'user.turn',
+            taskId: task.taskId,
+            turnId: 'dsh-ref-rejection',
+            workspace,
+            request: {
+                text: 'Find hotels'
+            }
+        }
+    }), /planner_invalid_action/, message);
+    await planner.close();
+}
+const firstAlias = 'modelref:'.concat(createHash('sha256').update(collisionRawRefs[0], 'utf8').digest('hex'));
+await assertFactRefsRejected([
+    collisionRawRefs[0],
+    firstAlias
+], 'unsafe raw ref cannot alias a same-action reserved modelref');
+await assertFactRefsRejected([
+    collisionRawRefs[0],
+    collisionRawRefs[0]
+], 'repair-time duplicate factRefs are rejected by canonical validation');
+await assertFactRefsRejected([
+    'modelref:'.concat('a'.repeat(64))
+], 'direct modelref namespace input is reserved and rejected');
+const reservedRecovery = await createDshEmbeddedBookingPlanner({
+    runPort: {
+        async run () {
+            return {
+                finalResponse: JSON.stringify({
+                    kind: 'operation',
+                    action: {
+                        ...searchRun,
+                        factRefs: [
+                            'modelref:'.concat('b'.repeat(64))
+                        ]
+                    }
+                }),
+                events: []
+            };
+        },
+        async close () {}
+    }
+});
+const reservedRecoveryDecision = await reservedRecovery.plannerFactory(task).next({
+    task,
+    turn: {
+        schemaVersion: 'booking.surface',
+        kind: 'user.turn',
+        taskId: task.taskId,
+        turnId: 'dsh-reserved-recovery',
+        workspace,
+        request: {
+            text: 'Find hotels'
+        }
+    }
+});
+assert.equal(reservedRecoveryDecision[0]?.kind, 'error', 'finalResponse recovery rejects direct reserved modelref aliases');
+await reservedRecovery.close();
+let stableRefCall = 0;
+const stableRawRef = 'fact://same/raw';
+const stablePlanner = await createDshEmbeddedBookingPlanner({
+    runPort: {
+        async run () {
+            stableRefCall += 1;
+            return {
+                finalResponse: '',
+                events: [
+                    {
+                        type: 'tool/call',
+                        data: {
+                            name: 'booking_search_hotels',
+                            arguments: JSON.stringify({
+                                decision: {
+                                    kind: 'operation',
+                                    action: {
+                                        ...searchRun,
+                                        actionId: `action-dsh-stable-${stableRefCall}`,
+                                        factRefs: [
+                                            stableRawRef
+                                        ]
+                                    }
+                                }
+                            })
+                        }
+                    }
+                ]
+            };
+        },
+        async close () {}
+    }
+});
+const stableFirst = await stablePlanner.plannerFactory(task).next({
+    task,
+    turn: {
+        schemaVersion: 'booking.surface',
+        kind: 'user.turn',
+        taskId: task.taskId,
+        turnId: 'dsh-stable-1',
+        workspace,
+        request: {
+            text: 'Find hotels'
+        }
+    }
+});
+const stableSecond = await stablePlanner.plannerFactory(task).next({
+    task,
+    turn: {
+        schemaVersion: 'booking.surface',
+        kind: 'user.turn',
+        taskId: task.taskId,
+        turnId: 'dsh-stable-2',
+        workspace,
+        request: {
+            text: 'Find hotels again'
+        }
+    }
+});
+assert.equal(stableFirst[0].action?.factRefs?.[0], stableSecond[0].action?.factRefs?.[0], 'same raw ref is stable across actions and turns');
+await stablePlanner.close();
 const unauthorisedPort = {
     async run () {
         return {
@@ -458,7 +667,7 @@ const fragmentDecisions = await fragmentRef.plannerFactory(task).next({
 });
 assert.equal(fragmentDecisions[0]?.kind, 'operation', 'JSON-pointer fragment factRefs repair into the safe charset');
 assert.deepEqual(fragmentDecisions[0].action?.factRefs, [
-    `fact:..turn_${task.lastTurnId}.request`
+    `modelref:c7819d3c0c375fe1bd389006338b99be890fa8e3ddd9390f243cba8b5c139d9a`
 ]);
 await fragmentRef.close();
 const truncatedPort = {

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

@@ -142,7 +142,137 @@ const action = (id, revision = 0, extra = {})=>({
         input: {},
         ...extra
     });
-let id = 0;
+const repairedFactRef = `modelref:${'a'.repeat(64)}`;
+{
+    const root = mkdtempSync(join(tmpdir(), 'gotry-booking-v2-factref-action-authority-'));
+    const ledger = ensureLedger(root);
+    const rt = new BookingCopilotTaskRuntime(ledger, {
+        contextRefFactory: ()=>'ctx-v2'
+    });
+    const limitedWorkspace = {
+        ...workspace(0),
+        capabilities: {
+            surface: 'tenant',
+            allowedActions: [
+                'search.run'
+            ]
+        }
+    };
+    const t = rt.startTask({
+        ...turn('task-factref-action-authority'),
+        workspace: limitedWorkspace
+    });
+    const before = ledger.countEvents();
+    assert.throws(()=>rt.issueOperation(t.taskId, {
+            ...action('factref-forged-action', 0, {
+                factRefs: [
+                    repairedFactRef,
+                    'checkout.prepare'
+                ]
+            }),
+            kind: 'checkout.prepare',
+            input: {
+                offerRef: 'offer-a',
+                offerVersionRef: 'offer-a:v1',
+                verifiedOfferRef: 'verified-offer-a'
+            }
+        }), /unsupported_action/, 'factRefs cannot add an action to the surface allowlist');
+    assert.equal(ledger.countEvents(), before, 'rejected factRef authority does not persist an operation');
+    ledger.close();
+    rmSync(root, {
+        recursive: true,
+        force: true
+    });
+}{
+    const root = mkdtempSync(join(tmpdir(), 'gotry-booking-v2-factref-offer-authority-'));
+    const ledger = ensureLedger(root);
+    const rt = new BookingCopilotTaskRuntime(ledger, {
+        contextRefFactory: ()=>'ctx-v2'
+    });
+    const offerWorkspace = {
+        ...workspace(0),
+        visibleHotels: [
+            {
+                hotelRef: 'hotel-a',
+                name: 'Hotel A',
+                factRefs: []
+            }
+        ],
+        loadedOffers: [
+            loadedOffer('offer-a', 'hotel-a', 'offer-a:v1')
+        ]
+    };
+    const t = rt.startTask({
+        ...turn('task-factref-offer-authority'),
+        workspace: offerWorkspace
+    });
+    const before = ledger.countEvents();
+    assert.throws(()=>rt.issueOperation(t.taskId, {
+            ...action('factref-forged-version', 0, {
+                factRefs: [
+                    repairedFactRef,
+                    'offer-a:v2'
+                ]
+            }),
+            kind: 'offer.check',
+            input: {
+                offerRef: 'offer-a',
+                offerVersionRef: 'offer-a:v2'
+            }
+        }), /offer_version_not_loaded/, 'factRefs cannot promote an unloaded offer version');
+    assert.equal(ledger.countEvents(), before, 'rejected factRef version does not persist an operation');
+    ledger.close();
+    rmSync(root, {
+        recursive: true,
+        force: true
+    });
+}{
+    const root = mkdtempSync(join(tmpdir(), 'gotry-booking-v2-factref-verified-authority-'));
+    const ledger = ensureLedger(root);
+    const rt = new BookingCopilotTaskRuntime(ledger, {
+        contextRefFactory: ()=>'ctx-v2',
+        now: ()=>'2026-09-01T10:00:00.000Z'
+    });
+    const offerWorkspace = {
+        ...workspace(0),
+        visibleHotels: [
+            {
+                hotelRef: 'hotel-a',
+                name: 'Hotel A',
+                factRefs: []
+            }
+        ],
+        loadedOffers: [
+            loadedOffer('offer-a', 'hotel-a', 'offer-a:v1')
+        ],
+        selectedOfferRef: 'offer-a'
+    };
+    const t = rt.startTask({
+        ...turn('task-factref-verified-authority'),
+        workspace: offerWorkspace
+    });
+    const before = ledger.countEvents();
+    assert.throws(()=>rt.issueOperation(t.taskId, {
+            ...action('factref-forged-verified', 0, {
+                factRefs: [
+                    repairedFactRef,
+                    'verified-offer-a'
+                ]
+            }),
+            kind: 'checkout.prepare',
+            input: {
+                offerRef: 'offer-a',
+                offerVersionRef: 'offer-a:v1',
+                verifiedOfferRef: 'verified-offer-a'
+            }
+        }), /offer_version_not_loaded/, 'factRefs cannot create verified-offer authority');
+    assert.equal(ledger.countEvents(), before, 'rejected factRef verification does not persist an operation');
+    ledger.close();
+    rmSync(root, {
+        recursive: true,
+        force: true
+    });
+}let id = 0;
 const runtime = new BookingCopilotTaskRuntime(ensureLedger(stateRoot), {
     idFactory: (prefix)=>`${prefix}-${++id}`,
     now: ()=>'2026-09-01T10:00:00.000Z'
@@ -3997,7 +4127,7 @@ rmSync(offerRoot, {
     recursive: true,
     force: true
 });
-console.log('BOOKING COPILOT RUNTIME PROOF: task scope, receipt binding, approval authority/one-time, recovery, ingress/SSE session OK');
+console.log('BOOKING COPILOT RUNTIME PROOF: task scope, receipt binding, factRef non-authority, approval authority/one-time, recovery, ingress/SSE session OK');
 
 
 //# sourceURL=ts/scripts/booking-copilot-runtime-proof-tests.ts

package/dist/scripts/bootstrap-tests.js

@@ -76,7 +76,8 @@ const c6 = runBootstrap([
 ], {
     GOTRY_SETUP_EXTENSION: '0',
     GOTRY_ONBOARDING_TIMEOUT_MS: '600',
-    GOTRY_ONBOARDING_INTERVAL_MS: '200'
+    GOTRY_ONBOARDING_INTERVAL_MS: '200',
+    GOTRY_ONBOARDING_BRIDGE_PORTS: '0'
 });
 assert.equal(c6.code, 1, `wizard(超时)应 exit 1,实际 ${c6.code}\n${c6.out}`);
 assert.ok(c6.out.includes('gotry-wizard'), '应输出 [gotry-wizard] 标签');

package/dist/scripts/hbcli-e2e-tests.js

@@ -10,7 +10,7 @@ const SANDBOX_APP_KEY = 'hotelbyte_api_demo';
 const SANDBOX_APP_SECRET = 'hotelbyte_api_demo';
 const GUIDANCE = [
     'staicli(hbcli)账号配置指引:',
-    '  1. 安装 CLI(若缺):npx gotry setup(官方 install.sh → ~/.local/bin/hbcli)',
+    '  1. 安装 CLI(若缺):npx gotry setup(npm 装 staicli@npmjs → PATH 的 hbcli)',
     '  2. 快速试用(沙箱演示账号,来自 hotel-be 种子,user/domain/predefined_user_demo.go):',
     '     hbcli auth set-credentials --app-key hotelbyte_api_demo --app-secret hotelbyte_api_demo',
     '  3. 正式接入:向 HotelByte 申请专属 appKey/appSecret(hbk_*/hbs_*),替换第 2 步凭证;',

package/dist/scripts/health-watch-cli.js

@@ -15,6 +15,13 @@ function parseArgs(argv) {
     }
     if (Number.isNaN(args.timeoutMs) || args.timeoutMs < 0) args.timeoutMs = 120_000;
     if (Number.isNaN(args.intervalMs) || args.intervalMs < 1_000) args.intervalMs = 5_000;
+    const rawPorts = process.env.GOTRY_ONBOARDING_BRIDGE_PORTS;
+    if (rawPorts) {
+        const parsed = rawPorts.split(',').map((part)=>Number.parseInt(part.trim(), 10));
+        if (parsed.every((port)=>Number.isInteger(port) && port >= 0 && port <= 65535)) {
+            args.ports = parsed;
+        }
+    }
     return args;
 }
 async function main() {
@@ -24,7 +31,8 @@ async function main() {
         timeoutMs: args.timeoutMs,
         intervalMs: args.intervalMs,
         keepBridge: true,
-        businessProbe
+        businessProbe,
+        ports: args.ports
     });
     process.on('SIGINT', ()=>{
         watch.cancel('SIGINT');