quick-acp 0.0.0-stage → 0.1.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +405 -2
- package/dist/acp/agent.js +384 -0
- package/dist/acp-smoke.js +163 -0
- package/dist/concurrent-test.js +101 -0
- package/dist/doctor.js +86 -0
- package/dist/e2e.js +206 -0
- package/dist/fresh-machine-e2e.js +151 -0
- package/dist/inject-turn-test.js +119 -0
- package/dist/login-cli.js +86 -0
- package/dist/main.js +77 -0
- package/dist/no-outpost-e2e.js +86 -0
- package/dist/probe.js +308 -0
- package/dist/quick/auth.js +371 -0
- package/dist/quick/codec.js +499 -0
- package/dist/quick/credstore.js +439 -0
- package/dist/quick/gateway-contract.js +104 -0
- package/dist/quick/login.js +522 -0
- package/dist/quick/oidc.js +152 -0
- package/dist/quick/session-direct.js +200 -0
- package/dist/quick/session.js +399 -0
- package/dist/quick/transport.js +343 -0
- package/dist/session-id-test.js +95 -0
- package/dist/tools/registry.js +411 -0
- package/dist/tools/strategies.js +188 -0
- package/dist/wss-smoke.js +230 -0
- package/package.json +54 -5
|
@@ -0,0 +1,499 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Quick gateway wire codec.
|
|
3
|
+
*
|
|
4
|
+
* Two independent facts were recovered from the shipped build, and they
|
|
5
|
+
* DISAGREE with each other. Both are reproduced here and the choice is a
|
|
6
|
+
* runtime option, because the evidence does not establish which one the
|
|
7
|
+
* server accepts today.
|
|
8
|
+
*
|
|
9
|
+
* A) Main process (dist/main/gatewayBidiCodec.js) 鈥?used by the IPC proxy
|
|
10
|
+
* path, which is the default in the shipping build because a browser
|
|
11
|
+
* WebSocket cannot set an Authorization header.
|
|
12
|
+
* send: event-stream{ :event-type=rawInputEvent,
|
|
13
|
+
* :content-type=application/cbor,
|
|
14
|
+
* :message-type=event }
|
|
15
|
+
* payload = CBOR({ payload: <utf8 bytes of json> })
|
|
16
|
+
* receive: event-stream payload = CBOR({ payload: <utf8 bytes> })
|
|
17
|
+
*
|
|
18
|
+
* B) Renderer (startup-*.js, functions CUe / EUe) 鈥?used by the direct
|
|
19
|
+
* browser WebSocket path.
|
|
20
|
+
* send: PLAIN TEXT (no event-stream at all)
|
|
21
|
+
* utf8( JSON.stringify({ eventType: "rawInputEvent",
|
|
22
|
+
* payload: { payload: <base64> } }) )
|
|
23
|
+
* receive: event-stream payload = utf8 JSON { payload: <base64 string> }
|
|
24
|
+
* -> base64 decode -> utf8 -> inner json
|
|
25
|
+
*
|
|
26
|
+
* A is symmetric CBOR; B is symmetric JSON/base64. They are not two views of
|
|
27
|
+
* one format. `mode` selects which framing this client speaks.
|
|
28
|
+
*/
|
|
29
|
+
const _enc = new TextEncoder();
|
|
30
|
+
const _dec = new TextDecoder();
|
|
31
|
+
// ---------------------------------------------------------------------------
|
|
32
|
+
// CBOR (only the shapes this protocol uses)
|
|
33
|
+
// ---------------------------------------------------------------------------
|
|
34
|
+
function cborHead(major, n, out) {
|
|
35
|
+
const mt = major << 5;
|
|
36
|
+
if (n < 24)
|
|
37
|
+
out.push(mt | n);
|
|
38
|
+
else if (n < 0x100)
|
|
39
|
+
out.push(mt | 24, n);
|
|
40
|
+
else if (n < 0x10000)
|
|
41
|
+
out.push(mt | 25, (n >> 8) & 0xff, n & 0xff);
|
|
42
|
+
else if (n < 0x100000000)
|
|
43
|
+
out.push(mt | 26, (n >>> 24) & 0xff, (n >>> 16) & 0xff, (n >>> 8) & 0xff, n & 0xff);
|
|
44
|
+
else {
|
|
45
|
+
const hi = Math.floor(n / 0x100000000);
|
|
46
|
+
const lo = n >>> 0;
|
|
47
|
+
out.push(mt | 27, (hi >>> 24) & 0xff, (hi >>> 16) & 0xff, (hi >>> 8) & 0xff, hi & 0xff, (lo >>> 24) & 0xff, (lo >>> 16) & 0xff, (lo >>> 8) & 0xff, lo & 0xff);
|
|
48
|
+
}
|
|
49
|
+
}
|
|
50
|
+
function cborEncInto(v, out) {
|
|
51
|
+
if (v === null || v === undefined)
|
|
52
|
+
out.push(0xf6);
|
|
53
|
+
else if (v === true)
|
|
54
|
+
out.push(0xf5);
|
|
55
|
+
else if (v === false)
|
|
56
|
+
out.push(0xf4);
|
|
57
|
+
else if (typeof v === 'number') {
|
|
58
|
+
if (Number.isInteger(v) && v >= 0 && v < 2 ** 53)
|
|
59
|
+
cborHead(0, v, out);
|
|
60
|
+
else if (Number.isInteger(v) && v < 0 && v > -(2 ** 53))
|
|
61
|
+
cborHead(1, -1 - v, out);
|
|
62
|
+
else {
|
|
63
|
+
out.push(0xfb);
|
|
64
|
+
const buf = new ArrayBuffer(8);
|
|
65
|
+
new DataView(buf).setFloat64(0, v, false);
|
|
66
|
+
for (const b of new Uint8Array(buf))
|
|
67
|
+
out.push(b);
|
|
68
|
+
}
|
|
69
|
+
}
|
|
70
|
+
else if (v instanceof Uint8Array) {
|
|
71
|
+
cborHead(2, v.length, out);
|
|
72
|
+
for (const b of v)
|
|
73
|
+
out.push(b);
|
|
74
|
+
}
|
|
75
|
+
else if (typeof v === 'string') {
|
|
76
|
+
const b = _enc.encode(v);
|
|
77
|
+
cborHead(3, b.length, out);
|
|
78
|
+
for (const x of b)
|
|
79
|
+
out.push(x);
|
|
80
|
+
}
|
|
81
|
+
else if (Array.isArray(v)) {
|
|
82
|
+
cborHead(4, v.length, out);
|
|
83
|
+
for (const item of v)
|
|
84
|
+
cborEncInto(item, out);
|
|
85
|
+
}
|
|
86
|
+
else if (typeof v === 'object') {
|
|
87
|
+
const entries = Object.entries(v);
|
|
88
|
+
cborHead(5, entries.length, out);
|
|
89
|
+
for (const [k, val] of entries) {
|
|
90
|
+
cborEncInto(k, out);
|
|
91
|
+
cborEncInto(val, out);
|
|
92
|
+
}
|
|
93
|
+
}
|
|
94
|
+
else {
|
|
95
|
+
throw new TypeError(`cannot CBOR-encode ${typeof v}`);
|
|
96
|
+
}
|
|
97
|
+
}
|
|
98
|
+
export function cborEncode(value) {
|
|
99
|
+
const out = [];
|
|
100
|
+
cborEncInto(value, out);
|
|
101
|
+
return new Uint8Array(out);
|
|
102
|
+
}
|
|
103
|
+
function cborDecodeAt(data, start) {
|
|
104
|
+
let i = start;
|
|
105
|
+
const ib = data[i++];
|
|
106
|
+
const major = ib >> 5;
|
|
107
|
+
const ai = ib & 0x1f;
|
|
108
|
+
if (major === 7) {
|
|
109
|
+
if (ai === 20)
|
|
110
|
+
return [false, i];
|
|
111
|
+
if (ai === 21)
|
|
112
|
+
return [true, i];
|
|
113
|
+
if (ai === 22 || ai === 23)
|
|
114
|
+
return [null, i];
|
|
115
|
+
if (ai === 25) {
|
|
116
|
+
const h = (data[i] << 8) | data[i + 1];
|
|
117
|
+
i += 2;
|
|
118
|
+
const sign = h & 0x8000 ? -1 : 1;
|
|
119
|
+
const exp = (h >> 10) & 0x1f;
|
|
120
|
+
const mant = h & 0x3ff;
|
|
121
|
+
if (exp === 0)
|
|
122
|
+
return [sign * mant * 2 ** -24, i];
|
|
123
|
+
if (exp === 31)
|
|
124
|
+
return [mant === 0 ? sign * Infinity : NaN, i];
|
|
125
|
+
return [sign * (1024 + mant) * 2 ** (exp - 25), i];
|
|
126
|
+
}
|
|
127
|
+
if (ai === 26)
|
|
128
|
+
return [new DataView(data.buffer, data.byteOffset + i, 4).getFloat32(0, false), i + 4];
|
|
129
|
+
if (ai === 27)
|
|
130
|
+
return [new DataView(data.buffer, data.byteOffset + i, 8).getFloat64(0, false), i + 8];
|
|
131
|
+
return [null, i];
|
|
132
|
+
}
|
|
133
|
+
let n;
|
|
134
|
+
if (ai < 24)
|
|
135
|
+
n = ai;
|
|
136
|
+
else if (ai === 24) {
|
|
137
|
+
n = data[i++];
|
|
138
|
+
}
|
|
139
|
+
else if (ai === 25) {
|
|
140
|
+
n = (data[i] << 8) | data[i + 1];
|
|
141
|
+
i += 2;
|
|
142
|
+
}
|
|
143
|
+
else if (ai === 26) {
|
|
144
|
+
n = ((data[i] << 24) | (data[i + 1] << 16) | (data[i + 2] << 8) | data[i + 3]) >>> 0;
|
|
145
|
+
i += 4;
|
|
146
|
+
}
|
|
147
|
+
else if (ai === 27) {
|
|
148
|
+
let v = 0;
|
|
149
|
+
for (let k = 0; k < 8; k++)
|
|
150
|
+
v = v * 256 + data[i + k];
|
|
151
|
+
n = v;
|
|
152
|
+
i += 8;
|
|
153
|
+
}
|
|
154
|
+
else if (ai === 31) {
|
|
155
|
+
n = null;
|
|
156
|
+
}
|
|
157
|
+
else {
|
|
158
|
+
throw new Error('reserved CBOR additional-info');
|
|
159
|
+
}
|
|
160
|
+
if (major === 0)
|
|
161
|
+
return [n, i];
|
|
162
|
+
if (major === 1)
|
|
163
|
+
return [-1 - n, i];
|
|
164
|
+
if (major === 2) {
|
|
165
|
+
if (n === null) {
|
|
166
|
+
const chunks = [];
|
|
167
|
+
while (data[i] !== 0xff) {
|
|
168
|
+
const [c, ni] = cborDecodeAt(data, i);
|
|
169
|
+
chunks.push(...c);
|
|
170
|
+
i = ni;
|
|
171
|
+
}
|
|
172
|
+
return [new Uint8Array(chunks), i + 1];
|
|
173
|
+
}
|
|
174
|
+
const out = data.slice(i, i + n);
|
|
175
|
+
return [out, i + n];
|
|
176
|
+
}
|
|
177
|
+
if (major === 3) {
|
|
178
|
+
if (n === null) {
|
|
179
|
+
let s = '';
|
|
180
|
+
while (data[i] !== 0xff) {
|
|
181
|
+
const [c, ni] = cborDecodeAt(data, i);
|
|
182
|
+
s += c;
|
|
183
|
+
i = ni;
|
|
184
|
+
}
|
|
185
|
+
return [s, i + 1];
|
|
186
|
+
}
|
|
187
|
+
return [_dec.decode(data.slice(i, i + n)), i + n];
|
|
188
|
+
}
|
|
189
|
+
if (major === 4) {
|
|
190
|
+
const arr = [];
|
|
191
|
+
if (n === null) {
|
|
192
|
+
while (data[i] !== 0xff) {
|
|
193
|
+
const [v, ni] = cborDecodeAt(data, i);
|
|
194
|
+
arr.push(v);
|
|
195
|
+
i = ni;
|
|
196
|
+
}
|
|
197
|
+
return [arr, i + 1];
|
|
198
|
+
}
|
|
199
|
+
for (let k = 0; k < n; k++) {
|
|
200
|
+
const [v, ni] = cborDecodeAt(data, i);
|
|
201
|
+
arr.push(v);
|
|
202
|
+
i = ni;
|
|
203
|
+
}
|
|
204
|
+
return [arr, i];
|
|
205
|
+
}
|
|
206
|
+
if (major === 5) {
|
|
207
|
+
const obj = {};
|
|
208
|
+
if (n === null) {
|
|
209
|
+
while (data[i] !== 0xff) {
|
|
210
|
+
const [k, ki] = cborDecodeAt(data, i);
|
|
211
|
+
const [v, vi] = cborDecodeAt(data, ki);
|
|
212
|
+
obj[String(k)] = v;
|
|
213
|
+
i = vi;
|
|
214
|
+
}
|
|
215
|
+
return [obj, i + 1];
|
|
216
|
+
}
|
|
217
|
+
for (let k = 0; k < n; k++) {
|
|
218
|
+
const [key, ki] = cborDecodeAt(data, i);
|
|
219
|
+
const [val, vi] = cborDecodeAt(data, ki);
|
|
220
|
+
obj[String(key)] = val;
|
|
221
|
+
i = vi;
|
|
222
|
+
}
|
|
223
|
+
return [obj, i];
|
|
224
|
+
}
|
|
225
|
+
if (major === 6) {
|
|
226
|
+
const [v, ni] = cborDecodeAt(data, i);
|
|
227
|
+
return [v, ni];
|
|
228
|
+
}
|
|
229
|
+
throw new Error(`bad CBOR major type ${major}`);
|
|
230
|
+
}
|
|
231
|
+
export function cborDecode(data) {
|
|
232
|
+
const [v] = cborDecodeAt(data, 0);
|
|
233
|
+
return v;
|
|
234
|
+
}
|
|
235
|
+
// ---------------------------------------------------------------------------
|
|
236
|
+
// AWS event-stream framing
|
|
237
|
+
// [total_len:4][headers_len:4][prelude_crc:4][headers][payload][msg_crc:4]
|
|
238
|
+
// big-endian; CRC32 zlib-compatible.
|
|
239
|
+
//
|
|
240
|
+
// Header entry format (NOT CBOR): [name_len:1][name][value_type:1][value]
|
|
241
|
+
// value_type 7 = string -> [len:2][utf8]
|
|
242
|
+
// ---------------------------------------------------------------------------
|
|
243
|
+
const CRC_TABLE = (() => {
|
|
244
|
+
const t = new Uint32Array(256);
|
|
245
|
+
for (let i = 0; i < 256; i++) {
|
|
246
|
+
let c = i;
|
|
247
|
+
for (let k = 0; k < 8; k++)
|
|
248
|
+
c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
|
|
249
|
+
t[i] = c >>> 0;
|
|
250
|
+
}
|
|
251
|
+
return t;
|
|
252
|
+
})();
|
|
253
|
+
function crc32(buf) {
|
|
254
|
+
let c = 0xffffffff;
|
|
255
|
+
for (let i = 0; i < buf.length; i++)
|
|
256
|
+
c = CRC_TABLE[(c ^ buf[i]) & 0xff] ^ (c >>> 8);
|
|
257
|
+
return (c ^ 0xffffffff) >>> 0;
|
|
258
|
+
}
|
|
259
|
+
const HV_STRING = 7;
|
|
260
|
+
export function esEncode(headers, payload) {
|
|
261
|
+
const hb = [];
|
|
262
|
+
for (const [name, value] of Object.entries(headers)) {
|
|
263
|
+
const nb = _enc.encode(name);
|
|
264
|
+
if (nb.length > 255)
|
|
265
|
+
throw new Error(`event-stream header name too long: ${name}`);
|
|
266
|
+
hb.push(nb.length);
|
|
267
|
+
for (const b of nb)
|
|
268
|
+
hb.push(b);
|
|
269
|
+
hb.push(HV_STRING);
|
|
270
|
+
const vb = _enc.encode(value);
|
|
271
|
+
hb.push((vb.length >> 8) & 0xff, vb.length & 0xff);
|
|
272
|
+
for (const b of vb)
|
|
273
|
+
hb.push(b);
|
|
274
|
+
}
|
|
275
|
+
const headersLen = hb.length;
|
|
276
|
+
const totalLen = 12 + headersLen + payload.length + 4;
|
|
277
|
+
const msg = new Uint8Array(totalLen);
|
|
278
|
+
const view = new DataView(msg.buffer);
|
|
279
|
+
view.setUint32(0, totalLen, false);
|
|
280
|
+
view.setUint32(4, headersLen, false);
|
|
281
|
+
view.setUint32(8, crc32(msg.slice(0, 8)), false);
|
|
282
|
+
msg.set(new Uint8Array(hb), 12);
|
|
283
|
+
msg.set(payload, 12 + headersLen);
|
|
284
|
+
view.setUint32(totalLen - 4, crc32(msg.slice(0, totalLen - 4)), false);
|
|
285
|
+
return msg;
|
|
286
|
+
}
|
|
287
|
+
export function esDrain(buffer, offset = 0) {
|
|
288
|
+
const messages = [];
|
|
289
|
+
let pos = offset;
|
|
290
|
+
while (pos + 16 <= buffer.length) {
|
|
291
|
+
const view = new DataView(buffer.buffer, buffer.byteOffset + pos);
|
|
292
|
+
const totalLen = view.getUint32(0, false);
|
|
293
|
+
const headersLen = view.getUint32(4, false);
|
|
294
|
+
if (totalLen < 16 || totalLen > 16 * 1024 * 1024) {
|
|
295
|
+
// Not a frame boundary we trust; step one byte like the app does.
|
|
296
|
+
pos += 1;
|
|
297
|
+
continue;
|
|
298
|
+
}
|
|
299
|
+
if (pos + totalLen > buffer.length)
|
|
300
|
+
break; // incomplete
|
|
301
|
+
const hstart = pos + 12;
|
|
302
|
+
const hend = hstart + headersLen;
|
|
303
|
+
if (hend > buffer.length)
|
|
304
|
+
break;
|
|
305
|
+
const hend_ = pos + totalLen - 4;
|
|
306
|
+
if (hend_ < hend)
|
|
307
|
+
break;
|
|
308
|
+
const payload = buffer.slice(hend, hend_);
|
|
309
|
+
let ok = true;
|
|
310
|
+
try {
|
|
311
|
+
const hs = _decodeHeaders(buffer, hstart, hend);
|
|
312
|
+
messages.push({ headers: hs, payload });
|
|
313
|
+
}
|
|
314
|
+
catch {
|
|
315
|
+
ok = false;
|
|
316
|
+
}
|
|
317
|
+
if (!ok)
|
|
318
|
+
pos += 1;
|
|
319
|
+
else
|
|
320
|
+
pos += totalLen;
|
|
321
|
+
}
|
|
322
|
+
return { messages, consumed: pos - offset };
|
|
323
|
+
}
|
|
324
|
+
function _decodeHeaders(buffer, start, end) {
|
|
325
|
+
const headers = {};
|
|
326
|
+
let j = start;
|
|
327
|
+
while (j < end) {
|
|
328
|
+
const nl = buffer[j++];
|
|
329
|
+
const name = _dec.decode(buffer.slice(j, j + nl));
|
|
330
|
+
j += nl;
|
|
331
|
+
const vt = buffer[j++];
|
|
332
|
+
if (vt === 0)
|
|
333
|
+
headers[name] = true;
|
|
334
|
+
else if (vt === 1)
|
|
335
|
+
headers[name] = false;
|
|
336
|
+
else if (vt === 2) {
|
|
337
|
+
headers[name] = buffer[j];
|
|
338
|
+
j += 1;
|
|
339
|
+
}
|
|
340
|
+
else if (vt === 3) {
|
|
341
|
+
headers[name] = (buffer[j] << 8) | buffer[j + 1];
|
|
342
|
+
j += 2;
|
|
343
|
+
}
|
|
344
|
+
else if (vt === 4) {
|
|
345
|
+
headers[name] = new DataView(buffer.buffer, buffer.byteOffset + j, 4).getUint32(0, false);
|
|
346
|
+
j += 4;
|
|
347
|
+
}
|
|
348
|
+
else if (vt === 5) {
|
|
349
|
+
let v = 0;
|
|
350
|
+
for (let k = 0; k < 8; k++)
|
|
351
|
+
v = v * 256 + buffer[j + k];
|
|
352
|
+
headers[name] = v;
|
|
353
|
+
j += 8;
|
|
354
|
+
}
|
|
355
|
+
else if (vt === 6) {
|
|
356
|
+
const bl = (buffer[j] << 8) | buffer[j + 1];
|
|
357
|
+
j += 2;
|
|
358
|
+
headers[name] = buffer.slice(j, j + bl);
|
|
359
|
+
j += bl;
|
|
360
|
+
}
|
|
361
|
+
else if (vt === 7) {
|
|
362
|
+
const vl = (buffer[j] << 8) | buffer[j + 1];
|
|
363
|
+
j += 2;
|
|
364
|
+
headers[name] = _dec.decode(buffer.slice(j, j + vl));
|
|
365
|
+
j += vl;
|
|
366
|
+
}
|
|
367
|
+
else if (vt === 8) {
|
|
368
|
+
let v = 0;
|
|
369
|
+
for (let k = 0; k < 8; k++)
|
|
370
|
+
v = v * 256 + buffer[j + k];
|
|
371
|
+
headers[name] = v;
|
|
372
|
+
j += 8;
|
|
373
|
+
}
|
|
374
|
+
else if (vt === 9) {
|
|
375
|
+
headers[name] = buffer.slice(j, j + 16);
|
|
376
|
+
j += 16;
|
|
377
|
+
}
|
|
378
|
+
else
|
|
379
|
+
throw new Error(`unknown event-stream header value type ${vt}`);
|
|
380
|
+
}
|
|
381
|
+
return headers;
|
|
382
|
+
}
|
|
383
|
+
/**
|
|
384
|
+
* Framing the live gateway accepts for CHAT messages.
|
|
385
|
+
*
|
|
386
|
+
* 'cbor' opens the socket and gets session_connect acknowledged, but every
|
|
387
|
+
* later business message (session_list, user_message) is silently dropped —
|
|
388
|
+
* verified on the target tenant. Default is json-base64.
|
|
389
|
+
*/
|
|
390
|
+
export const DEFAULT_FRAMING = 'json-base64';
|
|
391
|
+
/**
|
|
392
|
+
* Encode one outbound Quick JSON message into the bytes to put on the socket.
|
|
393
|
+
*
|
|
394
|
+
* mode 'cbor' (main-process / IPC proxy path, the shipping default):
|
|
395
|
+
* event-stream with :event-type=rawInputEvent carrying CBOR({payload: bytes})
|
|
396
|
+
* mode 'json-base64' (renderer direct-WebSocket path):
|
|
397
|
+
* PLAIN TEXT utf8(JSON({eventType, payload:{payload: base64}}))
|
|
398
|
+
*/
|
|
399
|
+
export function encodeOutbound(jsonMessage, mode = DEFAULT_FRAMING) {
|
|
400
|
+
if (mode === 'cbor') {
|
|
401
|
+
const inner = cborEncode({ payload: _enc.encode(jsonMessage) });
|
|
402
|
+
return esEncode({
|
|
403
|
+
':event-type': 'rawInputEvent',
|
|
404
|
+
':content-type': 'application/cbor',
|
|
405
|
+
':message-type': 'event',
|
|
406
|
+
}, inner);
|
|
407
|
+
}
|
|
408
|
+
const b64 = Buffer.from(_enc.encode(jsonMessage)).toString('base64');
|
|
409
|
+
return _enc.encode(JSON.stringify({ eventType: 'rawInputEvent', payload: { payload: b64 } }));
|
|
410
|
+
}
|
|
411
|
+
/**
|
|
412
|
+
* Decode inbound event-stream payloads into inner JSON strings.
|
|
413
|
+
* Handles both the CBOR payload (main) and JSON+base64 payload (renderer).
|
|
414
|
+
*/
|
|
415
|
+
export function decodeInbound(msg, mode = DEFAULT_FRAMING) {
|
|
416
|
+
const mt = msg.headers[':message-type'];
|
|
417
|
+
if (mt === 'error' || mt === 'exception') {
|
|
418
|
+
const code = String(msg.headers[':error-code'] ??
|
|
419
|
+
msg.headers[':exception-type'] ??
|
|
420
|
+
'unknown');
|
|
421
|
+
let reason = String(msg.headers[':error-message'] ?? '');
|
|
422
|
+
if (!reason && msg.payload.length > 0) {
|
|
423
|
+
try {
|
|
424
|
+
const text = _dec.decode(msg.payload);
|
|
425
|
+
const parsed = JSON.parse(text);
|
|
426
|
+
const m = parsed?.message ?? parsed?.Message;
|
|
427
|
+
reason = typeof m === 'string' && m ? m : text;
|
|
428
|
+
}
|
|
429
|
+
catch {
|
|
430
|
+
reason = _dec.decode(msg.payload);
|
|
431
|
+
}
|
|
432
|
+
}
|
|
433
|
+
return { kind: 'error', code, body: `[${code}] ${reason}`.trim() };
|
|
434
|
+
}
|
|
435
|
+
if (msg.payload.length === 0)
|
|
436
|
+
return { kind: 'ignored', reason: 'empty-payload' };
|
|
437
|
+
// Try CBOR first: the shipping default. Falls through to JSON+base64.
|
|
438
|
+
const order = mode === 'cbor' ? ['cbor', 'json-base64'] : ['json-base64', 'cbor'];
|
|
439
|
+
for (const attempt of order) {
|
|
440
|
+
const json = attempt === 'cbor' ? _tryCborPayload(msg.payload) : _tryJsonBase64Payload(msg.payload);
|
|
441
|
+
if (json !== null)
|
|
442
|
+
return { kind: 'message', body: json };
|
|
443
|
+
}
|
|
444
|
+
return { kind: 'ignored', reason: 'unrecognized-payload' };
|
|
445
|
+
}
|
|
446
|
+
function _tryCborPayload(payload) {
|
|
447
|
+
let decoded;
|
|
448
|
+
try {
|
|
449
|
+
decoded = cborDecode(payload);
|
|
450
|
+
}
|
|
451
|
+
catch {
|
|
452
|
+
return null;
|
|
453
|
+
}
|
|
454
|
+
if (!decoded || typeof decoded !== 'object')
|
|
455
|
+
return null;
|
|
456
|
+
const inner = decoded['payload'];
|
|
457
|
+
let json = null;
|
|
458
|
+
if (inner instanceof Uint8Array)
|
|
459
|
+
json = _dec.decode(inner);
|
|
460
|
+
else if (typeof inner === 'string')
|
|
461
|
+
json = inner;
|
|
462
|
+
if (json === null)
|
|
463
|
+
return null;
|
|
464
|
+
return _looksLikeJson(json) ? json : null;
|
|
465
|
+
}
|
|
466
|
+
function _tryJsonBase64Payload(payload) {
|
|
467
|
+
let parsed;
|
|
468
|
+
try {
|
|
469
|
+
parsed = JSON.parse(_dec.decode(payload));
|
|
470
|
+
}
|
|
471
|
+
catch {
|
|
472
|
+
return null;
|
|
473
|
+
}
|
|
474
|
+
if (!parsed || typeof parsed !== 'object')
|
|
475
|
+
return null;
|
|
476
|
+
const b64 = parsed['payload'];
|
|
477
|
+
if (typeof b64 !== 'string')
|
|
478
|
+
return null;
|
|
479
|
+
try {
|
|
480
|
+
const json = Buffer.from(b64, 'base64').toString('utf8');
|
|
481
|
+
return _looksLikeJson(json) ? json : null;
|
|
482
|
+
}
|
|
483
|
+
catch {
|
|
484
|
+
return null;
|
|
485
|
+
}
|
|
486
|
+
}
|
|
487
|
+
function _looksLikeJson(text) {
|
|
488
|
+
const t = text.trim();
|
|
489
|
+
if (!t.startsWith('{') && !t.startsWith('['))
|
|
490
|
+
return false;
|
|
491
|
+
try {
|
|
492
|
+
JSON.parse(t);
|
|
493
|
+
return true;
|
|
494
|
+
}
|
|
495
|
+
catch {
|
|
496
|
+
return false;
|
|
497
|
+
}
|
|
498
|
+
}
|
|
499
|
+
//# sourceMappingURL=codec.js.map
|