opencode-tokscope 0.1.0 → 0.2.0
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/README.md +37 -78
- package/dist/tui.js +1766 -326
- package/package.json +23 -5
package/dist/tui.js
CHANGED
|
@@ -3,15 +3,572 @@ import {createComponent as _$createComponent5} from "@opentui/solid";
|
|
|
3
3
|
import {Plugin} from "@opencode/plugin/tui";
|
|
4
4
|
import {createSignal as createSignal4} from "solid-js";
|
|
5
5
|
|
|
6
|
-
// src/
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
6
|
+
// src/history/records.ts
|
|
7
|
+
var fieldsOf = function(value) {
|
|
8
|
+
if (typeof value !== "object" || value === null || Array.isArray(value))
|
|
9
|
+
return;
|
|
10
|
+
return value;
|
|
11
|
+
};
|
|
12
|
+
var stringValue = function(value) {
|
|
13
|
+
return typeof value === "string" ? value : undefined;
|
|
14
|
+
};
|
|
15
|
+
var nonEmptyString = function(value) {
|
|
16
|
+
return typeof value === "string" && value.length > 0 ? value : undefined;
|
|
17
|
+
};
|
|
18
|
+
var sessionIDFrom = function(value) {
|
|
19
|
+
return typeof value === "string" && SESSION_ID_PATTERN.test(value) ? value : undefined;
|
|
20
|
+
};
|
|
21
|
+
var finiteNumber = function(value) {
|
|
22
|
+
return typeof value === "number" && Number.isFinite(value) ? value : undefined;
|
|
23
|
+
};
|
|
24
|
+
var nonNegativeNumber = function(value) {
|
|
25
|
+
const parsed = finiteNumber(value);
|
|
26
|
+
return parsed !== undefined && parsed >= 0 ? parsed : undefined;
|
|
27
|
+
};
|
|
28
|
+
var optionalField = function(value, parse) {
|
|
29
|
+
if (value === undefined)
|
|
30
|
+
return { ok: true, value: undefined };
|
|
31
|
+
const parsed = parse(value);
|
|
32
|
+
return parsed === undefined ? { ok: false } : { ok: true, value: parsed };
|
|
33
|
+
};
|
|
34
|
+
var parseRows = function(raw, parse) {
|
|
35
|
+
if (!Array.isArray(raw))
|
|
36
|
+
return;
|
|
37
|
+
const rows = [];
|
|
38
|
+
for (const entry of raw) {
|
|
39
|
+
const row = parse(entry);
|
|
40
|
+
if (row === undefined)
|
|
41
|
+
return;
|
|
42
|
+
rows.push(row);
|
|
43
|
+
}
|
|
44
|
+
return rows;
|
|
45
|
+
};
|
|
46
|
+
var parseSample = function(raw) {
|
|
47
|
+
const source = fieldsOf(raw);
|
|
48
|
+
if (source === undefined)
|
|
49
|
+
return;
|
|
50
|
+
const providerID = nonEmptyString(source.providerID);
|
|
51
|
+
const modelID = nonEmptyString(source.modelID);
|
|
52
|
+
const variant = optionalField(source.variant, stringValue);
|
|
53
|
+
const completedAt = finiteNumber(source.completedAt);
|
|
54
|
+
const rate = nonNegativeNumber(source.rate);
|
|
55
|
+
if (providerID === undefined || modelID === undefined || !variant.ok || completedAt === undefined || rate === undefined) {
|
|
56
|
+
return;
|
|
57
|
+
}
|
|
58
|
+
return { providerID, modelID, variant: variant.value, completedAt, rate };
|
|
59
|
+
};
|
|
60
|
+
var parseUnavailableSample = function(raw) {
|
|
61
|
+
const source = fieldsOf(raw);
|
|
62
|
+
if (source === undefined)
|
|
63
|
+
return;
|
|
64
|
+
const providerID = nonEmptyString(source.providerID);
|
|
65
|
+
const modelID = nonEmptyString(source.modelID);
|
|
66
|
+
const variant = optionalField(source.variant, stringValue);
|
|
67
|
+
const completedAt = finiteNumber(source.completedAt);
|
|
68
|
+
if (providerID === undefined || modelID === undefined || !variant.ok || completedAt === undefined) {
|
|
69
|
+
return;
|
|
70
|
+
}
|
|
71
|
+
return { providerID, modelID, variant: variant.value, completedAt };
|
|
72
|
+
};
|
|
73
|
+
var parseSessionRecord = function(raw) {
|
|
74
|
+
const source = fieldsOf(raw);
|
|
75
|
+
if (source === undefined)
|
|
76
|
+
return;
|
|
77
|
+
const sessionID = sessionIDFrom(source.sessionID);
|
|
78
|
+
const directory = optionalField(source.directory, stringValue);
|
|
79
|
+
const createdAt = finiteNumber(source.createdAt);
|
|
80
|
+
const updatedAt = finiteNumber(source.updatedAt);
|
|
81
|
+
const scannedAtMs = finiteNumber(source.scannedAtMs);
|
|
82
|
+
const signature = stringValue(source.signature);
|
|
83
|
+
const fork = source.fork;
|
|
84
|
+
const complete = source.complete;
|
|
85
|
+
if (sessionID === undefined || !directory.ok || createdAt === undefined || updatedAt === undefined || scannedAtMs === undefined || signature === undefined || typeof fork !== "boolean" || typeof complete !== "boolean") {
|
|
86
|
+
return;
|
|
87
|
+
}
|
|
88
|
+
const samples = parseRows(source.samples, parseSample);
|
|
89
|
+
const unavailable = parseRows(source.unavailable, parseUnavailableSample);
|
|
90
|
+
if (samples === undefined || unavailable === undefined)
|
|
91
|
+
return;
|
|
92
|
+
return {
|
|
93
|
+
sessionID,
|
|
94
|
+
directory: directory.value,
|
|
95
|
+
createdAt,
|
|
96
|
+
updatedAt,
|
|
97
|
+
fork,
|
|
98
|
+
signature,
|
|
99
|
+
scannedAtMs,
|
|
100
|
+
complete,
|
|
101
|
+
samples,
|
|
102
|
+
unavailable
|
|
103
|
+
};
|
|
104
|
+
};
|
|
105
|
+
var parseIndexEntry = function(raw) {
|
|
106
|
+
const source = fieldsOf(raw);
|
|
107
|
+
if (source === undefined)
|
|
108
|
+
return;
|
|
109
|
+
const sessionID = sessionIDFrom(source.sessionID);
|
|
110
|
+
const directory = optionalField(source.directory, stringValue);
|
|
111
|
+
const updatedAt = finiteNumber(source.updatedAt);
|
|
112
|
+
if (sessionID === undefined || !directory.ok || updatedAt === undefined)
|
|
113
|
+
return;
|
|
114
|
+
return { sessionID, directory: directory.value, updatedAt };
|
|
115
|
+
};
|
|
116
|
+
var parseComparisonRow = function(raw) {
|
|
117
|
+
const source = fieldsOf(raw);
|
|
118
|
+
if (source === undefined)
|
|
119
|
+
return;
|
|
120
|
+
const key = nonEmptyString(source.key);
|
|
121
|
+
const providerID = nonEmptyString(source.providerID);
|
|
122
|
+
const modelID = nonEmptyString(source.modelID);
|
|
123
|
+
const calls = nonNegativeNumber(source.calls);
|
|
124
|
+
const unavailable = source.unavailable;
|
|
125
|
+
if (key === undefined || providerID === undefined || modelID === undefined || calls === undefined || typeof unavailable !== "boolean") {
|
|
126
|
+
return;
|
|
127
|
+
}
|
|
128
|
+
let median;
|
|
129
|
+
if (source.median === null)
|
|
130
|
+
median = null;
|
|
131
|
+
else {
|
|
132
|
+
const parsed = finiteNumber(source.median);
|
|
133
|
+
if (parsed === undefined)
|
|
134
|
+
return;
|
|
135
|
+
median = parsed;
|
|
136
|
+
}
|
|
137
|
+
return { key, providerID, modelID, median, calls, unavailable };
|
|
138
|
+
};
|
|
139
|
+
var parseWidgetRow = function(raw) {
|
|
140
|
+
const source = fieldsOf(raw);
|
|
141
|
+
if (source === undefined)
|
|
142
|
+
return;
|
|
143
|
+
const key = nonEmptyString(source.key);
|
|
144
|
+
const providerID = nonEmptyString(source.providerID);
|
|
145
|
+
const modelID = nonEmptyString(source.modelID);
|
|
146
|
+
const median = nonNegativeNumber(source.median);
|
|
147
|
+
const calls = nonNegativeNumber(source.calls);
|
|
148
|
+
if (key === undefined || providerID === undefined || modelID === undefined || median === undefined || calls === undefined) {
|
|
149
|
+
return;
|
|
150
|
+
}
|
|
151
|
+
return { key, providerID, modelID, median, calls };
|
|
152
|
+
};
|
|
153
|
+
function signatureFor(meta) {
|
|
154
|
+
return JSON.stringify([
|
|
155
|
+
meta.id,
|
|
156
|
+
meta.time.created,
|
|
157
|
+
meta.time.updated,
|
|
158
|
+
meta.location?.directory,
|
|
159
|
+
meta.cost,
|
|
160
|
+
meta.tokens,
|
|
161
|
+
meta.fork?.sessionID,
|
|
162
|
+
meta.fork?.boundary
|
|
163
|
+
]);
|
|
164
|
+
}
|
|
165
|
+
function emptyShard() {
|
|
166
|
+
return {
|
|
167
|
+
schemaVersion: CACHE_SCHEMA_VERSION,
|
|
168
|
+
metricVersion: METRIC_VERSION,
|
|
169
|
+
records: {},
|
|
170
|
+
index: {}
|
|
171
|
+
};
|
|
172
|
+
}
|
|
173
|
+
function parseShard(raw) {
|
|
174
|
+
const source = fieldsOf(raw);
|
|
175
|
+
if (source === undefined)
|
|
176
|
+
return;
|
|
177
|
+
if (source.schemaVersion !== CACHE_SCHEMA_VERSION)
|
|
178
|
+
return;
|
|
179
|
+
if (source.metricVersion !== METRIC_VERSION)
|
|
180
|
+
return;
|
|
181
|
+
const recordsSource = fieldsOf(source.records);
|
|
182
|
+
const indexSource = fieldsOf(source.index);
|
|
183
|
+
if (recordsSource === undefined || indexSource === undefined)
|
|
184
|
+
return;
|
|
185
|
+
const records = {};
|
|
186
|
+
for (const [key, value] of Object.entries(recordsSource)) {
|
|
187
|
+
const record = parseSessionRecord(value);
|
|
188
|
+
if (record === undefined || record.sessionID !== key)
|
|
189
|
+
continue;
|
|
190
|
+
records[key] = record;
|
|
191
|
+
}
|
|
192
|
+
const index = {};
|
|
193
|
+
for (const [key, value] of Object.entries(indexSource)) {
|
|
194
|
+
const entry = parseIndexEntry(value);
|
|
195
|
+
if (entry === undefined || entry.sessionID !== key)
|
|
196
|
+
continue;
|
|
197
|
+
index[key] = entry;
|
|
198
|
+
}
|
|
199
|
+
return { schemaVersion: CACHE_SCHEMA_VERSION, metricVersion: METRIC_VERSION, records, index };
|
|
200
|
+
}
|
|
201
|
+
function parseCoverage(raw) {
|
|
202
|
+
const source = fieldsOf(raw);
|
|
203
|
+
if (source === undefined)
|
|
204
|
+
return;
|
|
205
|
+
if (source.schemaVersion !== CACHE_SCHEMA_VERSION)
|
|
206
|
+
return;
|
|
207
|
+
const directoryFilter = optionalField(source.directoryFilter, stringValue);
|
|
208
|
+
const fullInventoryCompletedAt = optionalField(source.fullInventoryCompletedAt, finiteNumber);
|
|
209
|
+
const recentCatchUpAt = optionalField(source.recentCatchUpAt, finiteNumber);
|
|
210
|
+
if (!directoryFilter.ok || !fullInventoryCompletedAt.ok || !recentCatchUpAt.ok)
|
|
211
|
+
return;
|
|
212
|
+
return {
|
|
213
|
+
schemaVersion: CACHE_SCHEMA_VERSION,
|
|
214
|
+
directoryFilter: directoryFilter.value,
|
|
215
|
+
fullInventoryCompletedAt: fullInventoryCompletedAt.value,
|
|
216
|
+
recentCatchUpAt: recentCatchUpAt.value
|
|
217
|
+
};
|
|
218
|
+
}
|
|
219
|
+
function parseViewSnapshot(raw) {
|
|
220
|
+
const source = fieldsOf(raw);
|
|
221
|
+
if (source === undefined)
|
|
222
|
+
return;
|
|
223
|
+
if (source.schemaVersion !== CACHE_SCHEMA_VERSION)
|
|
224
|
+
return;
|
|
225
|
+
if (source.metricVersion !== METRIC_VERSION)
|
|
226
|
+
return;
|
|
227
|
+
if (!RANGE_FILTERS.includes(source.range))
|
|
228
|
+
return;
|
|
229
|
+
const directoryFilter = optionalField(source.directoryFilter, stringValue);
|
|
230
|
+
const lastCheckedAt = optionalField(source.lastCheckedAt, finiteNumber);
|
|
231
|
+
const savedAtMs = finiteNumber(source.savedAtMs);
|
|
232
|
+
const rows = parseRows(source.rows, parseComparisonRow);
|
|
233
|
+
if (!directoryFilter.ok || !lastCheckedAt.ok || savedAtMs === undefined || rows === undefined)
|
|
234
|
+
return;
|
|
235
|
+
return {
|
|
236
|
+
schemaVersion: CACHE_SCHEMA_VERSION,
|
|
237
|
+
metricVersion: METRIC_VERSION,
|
|
238
|
+
directoryFilter: directoryFilter.value,
|
|
239
|
+
range: source.range,
|
|
240
|
+
rows,
|
|
241
|
+
lastCheckedAt: lastCheckedAt.value,
|
|
242
|
+
savedAtMs
|
|
243
|
+
};
|
|
244
|
+
}
|
|
245
|
+
function parseWidgetSnapshot(raw) {
|
|
246
|
+
const source = fieldsOf(raw);
|
|
247
|
+
if (source === undefined)
|
|
248
|
+
return;
|
|
249
|
+
if (source.schemaVersion !== CACHE_SCHEMA_VERSION)
|
|
250
|
+
return;
|
|
251
|
+
if (source.metricVersion !== METRIC_VERSION)
|
|
252
|
+
return;
|
|
253
|
+
const rows = parseRows(source.rows, parseWidgetRow);
|
|
254
|
+
const savedAtMs = finiteNumber(source.savedAtMs);
|
|
255
|
+
if (rows === undefined || savedAtMs === undefined)
|
|
256
|
+
return;
|
|
257
|
+
return { schemaVersion: CACHE_SCHEMA_VERSION, metricVersion: METRIC_VERSION, rows, savedAtMs };
|
|
258
|
+
}
|
|
259
|
+
function parseTombstones(raw) {
|
|
260
|
+
const source = fieldsOf(raw);
|
|
261
|
+
if (source === undefined)
|
|
262
|
+
return;
|
|
263
|
+
if (!Array.isArray(source.sessionIDs))
|
|
264
|
+
return;
|
|
265
|
+
const sessionIDs = [];
|
|
266
|
+
for (const entry of source.sessionIDs) {
|
|
267
|
+
const sessionID = sessionIDFrom(entry);
|
|
268
|
+
if (sessionID !== undefined)
|
|
269
|
+
sessionIDs.push(sessionID);
|
|
270
|
+
}
|
|
271
|
+
return { sessionIDs };
|
|
272
|
+
}
|
|
273
|
+
function recordFrom(meta, scan, nowMs) {
|
|
274
|
+
return {
|
|
275
|
+
sessionID: meta.id,
|
|
276
|
+
directory: meta.location?.directory,
|
|
277
|
+
createdAt: meta.time.created,
|
|
278
|
+
updatedAt: meta.time.updated,
|
|
279
|
+
fork: meta.fork !== undefined,
|
|
280
|
+
signature: signatureFor(meta),
|
|
281
|
+
scannedAtMs: nowMs,
|
|
282
|
+
complete: true,
|
|
283
|
+
samples: scan.samples,
|
|
284
|
+
unavailable: scan.unavailable
|
|
285
|
+
};
|
|
286
|
+
}
|
|
287
|
+
var CACHE_SCHEMA_VERSION = 1;
|
|
288
|
+
var METRIC_VERSION = 1;
|
|
289
|
+
var SESSION_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
|
|
290
|
+
var RANGE_FILTERS = ["last7", "last30", "last90", "all"];
|
|
291
|
+
|
|
292
|
+
// src/history/durable.ts
|
|
293
|
+
function fnv1a(value) {
|
|
294
|
+
let hash = 2166136261;
|
|
295
|
+
for (let index = 0;index < value.length; index++) {
|
|
296
|
+
hash = Math.imul(hash ^ value.charCodeAt(index), 16777619) >>> 0;
|
|
297
|
+
}
|
|
298
|
+
return hash;
|
|
299
|
+
}
|
|
300
|
+
var shardIndex = function(sessionID) {
|
|
301
|
+
return fnv1a(sessionID) % SHARD_COUNT;
|
|
302
|
+
};
|
|
303
|
+
var shardName = function(index) {
|
|
304
|
+
return `shard:${index}`;
|
|
305
|
+
};
|
|
306
|
+
var shardStorageKey = function(index) {
|
|
307
|
+
return `${SHARD_PREFIX}${index}`;
|
|
308
|
+
};
|
|
309
|
+
var coverageKey = function(directoryFilter) {
|
|
310
|
+
if (directoryFilter === undefined)
|
|
311
|
+
return COVERAGE_ALL_KEY;
|
|
312
|
+
return `${COVERAGE_PREFIX}d${fnv1a(directoryFilter).toString(16).padStart(8, "0")}`;
|
|
313
|
+
};
|
|
314
|
+
var isCoverageKey = function(key) {
|
|
315
|
+
return key === COVERAGE_ALL_KEY || key.startsWith(`${COVERAGE_PREFIX}d`);
|
|
316
|
+
};
|
|
317
|
+
var viewSnapshotKey = function(slot) {
|
|
318
|
+
return `${VIEW_SNAPSHOT_PREFIX}${slot}`;
|
|
319
|
+
};
|
|
320
|
+
var snapshotSlot = function(key) {
|
|
321
|
+
if (!key.startsWith(VIEW_SNAPSHOT_PREFIX))
|
|
322
|
+
return;
|
|
323
|
+
const suffix = key.slice(VIEW_SNAPSHOT_PREFIX.length);
|
|
324
|
+
if (!/^(?:0|[1-9][0-9]*)$/.test(suffix))
|
|
325
|
+
return;
|
|
326
|
+
const slot = Number(suffix);
|
|
327
|
+
return slot < VIEW_SNAPSHOT_LIMIT ? slot : undefined;
|
|
328
|
+
};
|
|
329
|
+
var isSnapshotIndexKey = function(key) {
|
|
330
|
+
return snapshotSlot(key) !== undefined;
|
|
331
|
+
};
|
|
332
|
+
var sameView = function(a, b) {
|
|
333
|
+
return a.directoryFilter === b.directoryFilter && a.range === b.range;
|
|
334
|
+
};
|
|
335
|
+
var replaceDraft = function(draft, value) {
|
|
336
|
+
for (const key of Object.keys(draft))
|
|
337
|
+
delete draft[key];
|
|
338
|
+
Object.assign(draft, value);
|
|
339
|
+
};
|
|
340
|
+
var parseKeyIndex = function(payload, accept) {
|
|
341
|
+
const keys = payload === undefined ? undefined : payload.keys;
|
|
342
|
+
if (!Array.isArray(keys))
|
|
343
|
+
return [];
|
|
344
|
+
const result = [];
|
|
345
|
+
for (const entry of keys) {
|
|
346
|
+
if (typeof entry !== "string" || !accept(entry) || result.includes(entry))
|
|
347
|
+
continue;
|
|
348
|
+
result.push(entry);
|
|
349
|
+
}
|
|
350
|
+
return result;
|
|
351
|
+
};
|
|
352
|
+
var readKeyIndex = function(store, key, accept) {
|
|
353
|
+
return parseKeyIndex(store.read(key), accept);
|
|
354
|
+
};
|
|
355
|
+
var mergeTombstones = function(existing, added) {
|
|
356
|
+
const incoming = new Set(added);
|
|
357
|
+
const merged = existing.filter((sessionID) => !incoming.has(sessionID));
|
|
358
|
+
const seen = new Set;
|
|
359
|
+
for (const sessionID of added) {
|
|
360
|
+
if (seen.has(sessionID))
|
|
361
|
+
continue;
|
|
362
|
+
seen.add(sessionID);
|
|
363
|
+
merged.push(sessionID);
|
|
364
|
+
}
|
|
365
|
+
return merged.slice(-TOMBSTONE_LIMIT);
|
|
366
|
+
};
|
|
367
|
+
function createRepository(store) {
|
|
368
|
+
const readTombstones = () => parseTombstones(store.read(TOMBSTONES_KEY)) ?? { sessionIDs: [] };
|
|
369
|
+
const readSnapshotIndex = () => readKeyIndex(store, SNAPSHOTS_INDEX_KEY, isSnapshotIndexKey);
|
|
370
|
+
const liveSnapshots = (keys) => {
|
|
371
|
+
const live = [];
|
|
372
|
+
for (const key of keys) {
|
|
373
|
+
const slot = snapshotSlot(key);
|
|
374
|
+
if (slot === undefined)
|
|
375
|
+
continue;
|
|
376
|
+
const parsed = parseViewSnapshot(store.read(key));
|
|
377
|
+
if (parsed !== undefined)
|
|
378
|
+
live.push({ key, slot, snapshot: parsed });
|
|
379
|
+
}
|
|
380
|
+
return live;
|
|
381
|
+
};
|
|
382
|
+
return {
|
|
383
|
+
loadAllShards() {
|
|
384
|
+
const shards = new Map;
|
|
385
|
+
for (let index = 0;index < SHARD_COUNT; index++) {
|
|
386
|
+
const shard = parseShard(store.read(shardStorageKey(index)));
|
|
387
|
+
if (shard !== undefined)
|
|
388
|
+
shards.set(shardName(index), shard);
|
|
389
|
+
}
|
|
390
|
+
return shards;
|
|
391
|
+
},
|
|
392
|
+
async putRecords(records2, nowMs) {
|
|
393
|
+
const grouped = new Map;
|
|
394
|
+
for (const record of records2) {
|
|
395
|
+
const index = shardIndex(record.sessionID);
|
|
396
|
+
const group = grouped.get(index);
|
|
397
|
+
if (group === undefined)
|
|
398
|
+
grouped.set(index, [record]);
|
|
399
|
+
else
|
|
400
|
+
group.push(record);
|
|
401
|
+
}
|
|
402
|
+
for (const [index, group] of [...grouped].sort((a, b) => a[0] - b[0])) {
|
|
403
|
+
await store.write(shardStorageKey(index), (draft) => {
|
|
404
|
+
const shard = parseShard(draft) ?? emptyShard();
|
|
405
|
+
for (const record of group) {
|
|
406
|
+
shard.records[record.sessionID] = record;
|
|
407
|
+
shard.index[record.sessionID] = {
|
|
408
|
+
sessionID: record.sessionID,
|
|
409
|
+
directory: record.directory,
|
|
410
|
+
updatedAt: record.updatedAt
|
|
411
|
+
};
|
|
412
|
+
}
|
|
413
|
+
replaceDraft(draft, shard);
|
|
414
|
+
});
|
|
415
|
+
}
|
|
416
|
+
},
|
|
417
|
+
async removeSessions(sessionIDs, nowMs) {
|
|
418
|
+
if (sessionIDs.length === 0)
|
|
419
|
+
return;
|
|
420
|
+
await store.write(TOMBSTONES_KEY, (draft) => replaceDraft(draft, { sessionIDs: mergeTombstones(readTombstones().sessionIDs, sessionIDs) }));
|
|
421
|
+
const grouped = new Map;
|
|
422
|
+
for (const sessionID of sessionIDs) {
|
|
423
|
+
const index = shardIndex(sessionID);
|
|
424
|
+
const group = grouped.get(index);
|
|
425
|
+
if (group === undefined)
|
|
426
|
+
grouped.set(index, [sessionID]);
|
|
427
|
+
else
|
|
428
|
+
group.push(sessionID);
|
|
429
|
+
}
|
|
430
|
+
for (const [index, group] of [...grouped].sort((a, b) => a[0] - b[0])) {
|
|
431
|
+
const key = shardStorageKey(index);
|
|
432
|
+
if (store.read(key) === undefined)
|
|
433
|
+
continue;
|
|
434
|
+
await store.write(key, (draft) => {
|
|
435
|
+
const shard = parseShard(draft) ?? emptyShard();
|
|
436
|
+
for (const sessionID of group) {
|
|
437
|
+
delete shard.records[sessionID];
|
|
438
|
+
delete shard.index[sessionID];
|
|
439
|
+
}
|
|
440
|
+
replaceDraft(draft, shard);
|
|
441
|
+
});
|
|
442
|
+
}
|
|
443
|
+
},
|
|
444
|
+
loadTombstones() {
|
|
445
|
+
return readTombstones();
|
|
446
|
+
},
|
|
447
|
+
async clearTombstones(nowMs) {
|
|
448
|
+
await store.write(TOMBSTONES_KEY, (draft) => replaceDraft(draft, { sessionIDs: [] }));
|
|
449
|
+
},
|
|
450
|
+
readCoverage(directoryFilter) {
|
|
451
|
+
const record = parseCoverage(store.read(coverageKey(directoryFilter)));
|
|
452
|
+
if (record === undefined)
|
|
453
|
+
return;
|
|
454
|
+
return record.directoryFilter === directoryFilter ? record : undefined;
|
|
455
|
+
},
|
|
456
|
+
async writeCoverage(record) {
|
|
457
|
+
const key = coverageKey(record.directoryFilter);
|
|
458
|
+
await store.write(COVERAGE_INDEX_KEY, (draft) => {
|
|
459
|
+
const indexed = parseKeyIndex(draft, isCoverageKey);
|
|
460
|
+
replaceDraft(draft, { keys: indexed.includes(key) ? indexed : [...indexed, key] });
|
|
461
|
+
});
|
|
462
|
+
await store.write(key, (draft) => replaceDraft(draft, record));
|
|
463
|
+
},
|
|
464
|
+
readViewSnapshot(directoryFilter, range) {
|
|
465
|
+
const index = readSnapshotIndex();
|
|
466
|
+
for (let position = index.length - 1;position >= 0; position--) {
|
|
467
|
+
const snapshot = parseViewSnapshot(store.read(index[position]));
|
|
468
|
+
if (snapshot === undefined)
|
|
469
|
+
continue;
|
|
470
|
+
if (snapshot.directoryFilter === directoryFilter && snapshot.range === range)
|
|
471
|
+
return snapshot;
|
|
472
|
+
}
|
|
473
|
+
return;
|
|
474
|
+
},
|
|
475
|
+
async writeViewSnapshot(snapshot) {
|
|
476
|
+
const live = liveSnapshots(readSnapshotIndex());
|
|
477
|
+
const updated = live.filter((entry) => sameView(entry.snapshot, snapshot)).at(-1);
|
|
478
|
+
const kept = live.filter((entry) => !sameView(entry.snapshot, snapshot));
|
|
479
|
+
let slot;
|
|
480
|
+
if (updated !== undefined) {
|
|
481
|
+
slot = updated.slot;
|
|
482
|
+
} else {
|
|
483
|
+
const used = new Set(kept.map((entry) => entry.slot));
|
|
484
|
+
const free = Array.from({ length: VIEW_SNAPSHOT_LIMIT }, (_, candidate) => candidate).find((candidate) => !used.has(candidate));
|
|
485
|
+
if (free !== undefined) {
|
|
486
|
+
slot = free;
|
|
487
|
+
} else {
|
|
488
|
+
slot = kept[0].slot;
|
|
489
|
+
kept.shift();
|
|
490
|
+
}
|
|
491
|
+
}
|
|
492
|
+
const key = viewSnapshotKey(slot);
|
|
493
|
+
await store.write(key, (draft) => replaceDraft(draft, snapshot));
|
|
494
|
+
await store.write(SNAPSHOTS_INDEX_KEY, (draft) => {
|
|
495
|
+
const current = liveSnapshots(parseKeyIndex(draft, isSnapshotIndexKey)).filter((entry) => entry.key !== key && !sameView(entry.snapshot, snapshot)).map((entry) => entry.key);
|
|
496
|
+
replaceDraft(draft, { keys: [...current, key].slice(-VIEW_SNAPSHOT_LIMIT) });
|
|
497
|
+
});
|
|
498
|
+
},
|
|
499
|
+
readWidgetSnapshot() {
|
|
500
|
+
return parseWidgetSnapshot(store.read(WIDGET_SNAPSHOT_KEY));
|
|
501
|
+
},
|
|
502
|
+
async writeWidgetSnapshot(rows, nowMs) {
|
|
503
|
+
const snapshot = {
|
|
504
|
+
schemaVersion: CACHE_SCHEMA_VERSION,
|
|
505
|
+
metricVersion: METRIC_VERSION,
|
|
506
|
+
rows,
|
|
507
|
+
savedAtMs: nowMs
|
|
508
|
+
};
|
|
509
|
+
await store.write(WIDGET_SNAPSHOT_KEY, (draft) => replaceDraft(draft, snapshot));
|
|
510
|
+
},
|
|
511
|
+
async clear() {
|
|
512
|
+
const keys = [
|
|
513
|
+
...Array.from({ length: SHARD_COUNT }, (_, index) => shardStorageKey(index)),
|
|
514
|
+
TOMBSTONES_KEY,
|
|
515
|
+
COVERAGE_INDEX_KEY,
|
|
516
|
+
...readKeyIndex(store, COVERAGE_INDEX_KEY, isCoverageKey),
|
|
517
|
+
SNAPSHOTS_INDEX_KEY,
|
|
518
|
+
...Array.from({ length: VIEW_SNAPSHOT_LIMIT }, (_, slot) => viewSnapshotKey(slot)),
|
|
519
|
+
WIDGET_SNAPSHOT_KEY
|
|
520
|
+
];
|
|
521
|
+
for (const key of keys) {
|
|
522
|
+
if (store.read(key) === undefined)
|
|
523
|
+
continue;
|
|
524
|
+
await store.write(key, (draft) => replaceDraft(draft, {}));
|
|
525
|
+
}
|
|
526
|
+
}
|
|
527
|
+
};
|
|
528
|
+
}
|
|
529
|
+
var SHARD_COUNT = 64;
|
|
530
|
+
var TOMBSTONE_LIMIT = 1000;
|
|
531
|
+
var VIEW_SNAPSHOT_LIMIT = 8;
|
|
532
|
+
var SHARD_PREFIX = "tks.shard.";
|
|
533
|
+
var COVERAGE_PREFIX = "tks.coverage.";
|
|
534
|
+
var COVERAGE_ALL_KEY = "tks.coverage.all";
|
|
535
|
+
var COVERAGE_INDEX_KEY = "tks.coverage-index";
|
|
536
|
+
var TOMBSTONES_KEY = "tks.tombstones";
|
|
537
|
+
var SNAPSHOTS_INDEX_KEY = "tks.snapshots";
|
|
538
|
+
var VIEW_SNAPSHOT_PREFIX = "tks.snapshot.view.";
|
|
539
|
+
var WIDGET_SNAPSHOT_KEY = "tks.snapshot.widget24h";
|
|
540
|
+
|
|
541
|
+
// src/history/plugin-storage.ts
|
|
542
|
+
import {unwrap} from "solid-js/store";
|
|
543
|
+
function createPluginDurableStore(storage) {
|
|
544
|
+
const entries = new Map;
|
|
545
|
+
const entryOf = (key) => {
|
|
546
|
+
const existing = entries.get(key);
|
|
547
|
+
if (existing !== undefined)
|
|
548
|
+
return existing;
|
|
549
|
+
const [store2, update] = storage.store(`${KEY_PREFIX}${key}`, {
|
|
550
|
+
initial: {}
|
|
551
|
+
});
|
|
552
|
+
const entry = {
|
|
553
|
+
read: () => unwrap(store2),
|
|
554
|
+
write: (mutation) => update(mutation)
|
|
555
|
+
};
|
|
556
|
+
entries.set(key, entry);
|
|
557
|
+
return entry;
|
|
558
|
+
};
|
|
559
|
+
return {
|
|
560
|
+
read(key) {
|
|
561
|
+
return entryOf(key).read();
|
|
562
|
+
},
|
|
563
|
+
write(key, mutate) {
|
|
564
|
+
return entryOf(key).write(mutate);
|
|
565
|
+
}
|
|
566
|
+
};
|
|
567
|
+
}
|
|
568
|
+
var KEY_PREFIX = "history.";
|
|
569
|
+
|
|
570
|
+
// src/history/service.ts
|
|
571
|
+
import {createSignal} from "solid-js";
|
|
15
572
|
|
|
16
573
|
// src/filters.ts
|
|
17
574
|
function rangeStartMs(range, nowMs) {
|
|
@@ -29,22 +586,6 @@ function rangeStartMs(range, nowMs) {
|
|
|
29
586
|
var DEFAULT_FILTERS = { scope: "all", range: "last30", reasoning: "all" };
|
|
30
587
|
var DAY_MS = 86400000;
|
|
31
588
|
|
|
32
|
-
// src/format.ts
|
|
33
|
-
function formatRate(median) {
|
|
34
|
-
return `${median.toFixed(1)} tok/s`;
|
|
35
|
-
}
|
|
36
|
-
function formatDayLabel(date) {
|
|
37
|
-
const [year, month, day] = date.split("-").map(Number);
|
|
38
|
-
return new Intl.DateTimeFormat("en-US", { month: "short", day: "numeric" }).format(new Date(year, month - 1, day));
|
|
39
|
-
}
|
|
40
|
-
function formatCoverage(measured, unavailable) {
|
|
41
|
-
return unavailable > 0 ? `${measured} measured calls; ${unavailable} unavailable` : `${measured} measured calls`;
|
|
42
|
-
}
|
|
43
|
-
function modelDisplayName(models, providerID, modelID) {
|
|
44
|
-
const match = models?.find((model) => model.id === modelID && model.providerID === providerID);
|
|
45
|
-
return match?.name ?? `${providerID}/${modelID}`;
|
|
46
|
-
}
|
|
47
|
-
|
|
48
589
|
// src/metric.ts
|
|
49
590
|
function classifyAssistant(message) {
|
|
50
591
|
if (message.error !== undefined)
|
|
@@ -85,8 +626,10 @@ function classifyAssistant(message) {
|
|
|
85
626
|
}
|
|
86
627
|
|
|
87
628
|
// src/harvest.ts
|
|
88
|
-
async function
|
|
629
|
+
async function listSessions(client, options) {
|
|
89
630
|
const sessions = [];
|
|
631
|
+
const fromMs = options.fromMs;
|
|
632
|
+
const seenCursors = new Set;
|
|
90
633
|
let sessionCursor;
|
|
91
634
|
do {
|
|
92
635
|
const page = await client.session.list(sessionCursor === undefined ? {
|
|
@@ -95,168 +638,1068 @@ async function collectMeasurements(client, options = {}) {
|
|
|
95
638
|
...options.directory === undefined ? {} : { directory: options.directory }
|
|
96
639
|
} : { limit: SESSION_PAGE_SIZE, cursor: sessionCursor });
|
|
97
640
|
sessions.push(...page.data);
|
|
641
|
+
const stalePage = fromMs !== undefined && page.data.length > 0 && page.data.every((session) => session.time.updated < fromMs);
|
|
642
|
+
if (stalePage)
|
|
643
|
+
return { sessions, boundaryReached: true };
|
|
98
644
|
sessionCursor = page.cursor.next ?? undefined;
|
|
645
|
+
if (sessionCursor !== undefined) {
|
|
646
|
+
if (seenCursors.has(sessionCursor))
|
|
647
|
+
throw new Error("repeated cursor");
|
|
648
|
+
seenCursors.add(sessionCursor);
|
|
649
|
+
}
|
|
99
650
|
} while (sessionCursor !== undefined);
|
|
100
|
-
|
|
651
|
+
return { sessions, boundaryReached: true };
|
|
652
|
+
}
|
|
653
|
+
function inRangeSamples(result, fromMs) {
|
|
654
|
+
if (fromMs === undefined)
|
|
655
|
+
return result;
|
|
656
|
+
return {
|
|
657
|
+
samples: result.samples.filter((sample) => sample.completedAt >= fromMs),
|
|
658
|
+
unavailable: result.unavailable.filter((sample) => sample.completedAt >= fromMs)
|
|
659
|
+
};
|
|
660
|
+
}
|
|
661
|
+
function collectVariants(samples, unavailable) {
|
|
662
|
+
const variantSet = new Set;
|
|
663
|
+
for (const sample of samples)
|
|
664
|
+
if (sample.variant !== undefined)
|
|
665
|
+
variantSet.add(sample.variant);
|
|
666
|
+
for (const sample of unavailable)
|
|
667
|
+
if (sample.variant !== undefined)
|
|
668
|
+
variantSet.add(sample.variant);
|
|
669
|
+
return [...variantSet].sort();
|
|
670
|
+
}
|
|
671
|
+
async function scanMessages(client, session) {
|
|
101
672
|
const samples = [];
|
|
102
673
|
const unavailable = [];
|
|
103
|
-
const
|
|
104
|
-
let
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
if (
|
|
674
|
+
const seenCursors = new Set;
|
|
675
|
+
let messageCursor;
|
|
676
|
+
do {
|
|
677
|
+
const page = await client.message.list(messageCursor === undefined ? { sessionID: session.id, limit: MESSAGE_PAGE_SIZE, order: "desc", type: "assistant" } : { sessionID: session.id, limit: MESSAGE_PAGE_SIZE, type: "assistant", cursor: messageCursor });
|
|
678
|
+
for (const message of page.data) {
|
|
679
|
+
if (message.type !== "assistant")
|
|
680
|
+
continue;
|
|
681
|
+
if (session.fork !== undefined && message.time.created < session.time.created)
|
|
682
|
+
continue;
|
|
683
|
+
const result = classifyAssistant(message);
|
|
684
|
+
if (result.kind === "measured")
|
|
685
|
+
samples.push(result.sample);
|
|
686
|
+
else if (result.kind === "unavailable")
|
|
687
|
+
unavailable.push(result.sample);
|
|
688
|
+
}
|
|
689
|
+
messageCursor = page.cursor.next ?? undefined;
|
|
690
|
+
if (messageCursor !== undefined) {
|
|
691
|
+
if (seenCursors.has(messageCursor))
|
|
692
|
+
throw new Error("repeated cursor");
|
|
693
|
+
seenCursors.add(messageCursor);
|
|
694
|
+
}
|
|
695
|
+
} while (messageCursor !== undefined);
|
|
696
|
+
return { samples, unavailable };
|
|
697
|
+
}
|
|
698
|
+
var SESSION_PAGE_SIZE = 100;
|
|
699
|
+
var MESSAGE_PAGE_SIZE = 200;
|
|
700
|
+
|
|
701
|
+
// src/stats.ts
|
|
702
|
+
function median(values) {
|
|
703
|
+
if (values.length === 0)
|
|
704
|
+
return null;
|
|
705
|
+
const sorted = [...values].sort((a, b) => a - b);
|
|
706
|
+
const middle = Math.floor(sorted.length / 2);
|
|
707
|
+
if (sorted.length % 2 === 1)
|
|
708
|
+
return sorted[middle];
|
|
709
|
+
return (sorted[middle - 1] + sorted[middle]) / 2;
|
|
710
|
+
}
|
|
711
|
+
function applyReasoningFilter(samples, unavailable, filter) {
|
|
712
|
+
if (filter === "all")
|
|
713
|
+
return { samples, unavailable };
|
|
714
|
+
const matches = (variant) => filter === "unknown" ? variant === undefined : variant === filter;
|
|
715
|
+
return {
|
|
716
|
+
samples: samples.filter((sample) => matches(sample.variant)),
|
|
717
|
+
unavailable: unavailable.filter((sample) => matches(sample.variant))
|
|
718
|
+
};
|
|
719
|
+
}
|
|
720
|
+
function rowKey(providerID, modelID) {
|
|
721
|
+
return `${providerID}/${modelID}`;
|
|
722
|
+
}
|
|
723
|
+
function comparisonRows(samples, unavailable) {
|
|
724
|
+
const groups = new Map;
|
|
725
|
+
const ensure = (providerID, modelID) => {
|
|
726
|
+
const key = rowKey(providerID, modelID);
|
|
727
|
+
let group = groups.get(key);
|
|
728
|
+
if (group === undefined) {
|
|
729
|
+
group = { providerID, modelID, rates: [], unavailable: 0 };
|
|
730
|
+
groups.set(key, group);
|
|
731
|
+
}
|
|
732
|
+
return group;
|
|
733
|
+
};
|
|
734
|
+
for (const sample of samples)
|
|
735
|
+
ensure(sample.providerID, sample.modelID).rates.push(sample.rate);
|
|
736
|
+
for (const sample of unavailable)
|
|
737
|
+
ensure(sample.providerID, sample.modelID).unavailable++;
|
|
738
|
+
const rows = [...groups].map(([key, group]) => {
|
|
739
|
+
const measured = group.rates.length > 0;
|
|
740
|
+
return {
|
|
741
|
+
key,
|
|
742
|
+
providerID: group.providerID,
|
|
743
|
+
modelID: group.modelID,
|
|
744
|
+
median: measured ? median(group.rates) : null,
|
|
745
|
+
calls: group.rates.length,
|
|
746
|
+
unavailable: !measured && group.unavailable > 0
|
|
747
|
+
};
|
|
748
|
+
});
|
|
749
|
+
return rows.sort((a, b) => {
|
|
750
|
+
const unavailableOrder = Number(a.unavailable) - Number(b.unavailable);
|
|
751
|
+
if (unavailableOrder !== 0)
|
|
752
|
+
return unavailableOrder;
|
|
753
|
+
const medianOrder = (b.median ?? Number.NEGATIVE_INFINITY) - (a.median ?? Number.NEGATIVE_INFINITY);
|
|
754
|
+
if (medianOrder !== 0)
|
|
755
|
+
return medianOrder;
|
|
756
|
+
if (b.calls !== a.calls)
|
|
757
|
+
return b.calls - a.calls;
|
|
758
|
+
return a.key.localeCompare(b.key);
|
|
759
|
+
});
|
|
760
|
+
}
|
|
761
|
+
var dayStart = function(epochMs) {
|
|
762
|
+
const date = new Date(epochMs);
|
|
763
|
+
return new Date(date.getFullYear(), date.getMonth(), date.getDate());
|
|
764
|
+
};
|
|
765
|
+
function localDayKey(epochMs) {
|
|
766
|
+
const date = new Date(epochMs);
|
|
767
|
+
const month = String(date.getMonth() + 1).padStart(2, "0");
|
|
768
|
+
const day = String(date.getDate()).padStart(2, "0");
|
|
769
|
+
return `${date.getFullYear()}-${month}-${day}`;
|
|
770
|
+
}
|
|
771
|
+
function dailySeries(samples, key, fromMs, nowMs) {
|
|
772
|
+
const matching = samples.filter((sample) => rowKey(sample.providerID, sample.modelID) === key);
|
|
773
|
+
const startMs = fromMs ?? (matching.length > 0 ? Math.min(...matching.map((sample) => sample.completedAt)) : nowMs);
|
|
774
|
+
const byDay = new Map;
|
|
775
|
+
for (const sample of matching) {
|
|
776
|
+
const day = localDayKey(sample.completedAt);
|
|
777
|
+
const rates = byDay.get(day);
|
|
778
|
+
if (rates === undefined)
|
|
779
|
+
byDay.set(day, [sample.rate]);
|
|
780
|
+
else
|
|
781
|
+
rates.push(sample.rate);
|
|
782
|
+
}
|
|
783
|
+
const points = [];
|
|
784
|
+
const end = dayStart(nowMs);
|
|
785
|
+
for (const cursor = dayStart(startMs);cursor.getTime() <= end.getTime(); cursor.setDate(cursor.getDate() + 1)) {
|
|
786
|
+
const date = localDayKey(cursor.getTime());
|
|
787
|
+
const rates = byDay.get(date);
|
|
788
|
+
points.push({
|
|
789
|
+
date,
|
|
790
|
+
median: rates === undefined ? null : median(rates),
|
|
791
|
+
calls: rates?.length ?? 0
|
|
792
|
+
});
|
|
793
|
+
}
|
|
794
|
+
return points;
|
|
795
|
+
}
|
|
796
|
+
function windowRange(length, selected, size) {
|
|
797
|
+
const span = Math.max(0, Math.min(size, length));
|
|
798
|
+
if (span === 0)
|
|
799
|
+
return { start: 0, end: 0 };
|
|
800
|
+
const clamped = Math.max(0, Math.min(selected, length - 1));
|
|
801
|
+
const start = Math.max(0, Math.min(clamped - Math.floor(span / 2), length - span));
|
|
802
|
+
return { start, end: start + span };
|
|
803
|
+
}
|
|
804
|
+
function dayWindow(series, selected, width) {
|
|
805
|
+
return windowRange(series.length, selected, width);
|
|
806
|
+
}
|
|
807
|
+
function barLevels(series, rows) {
|
|
808
|
+
const max = Math.max(0, ...series.map((point) => point.median ?? 0));
|
|
809
|
+
return series.map((point) => {
|
|
810
|
+
if (point.median === null || max <= 0)
|
|
811
|
+
return null;
|
|
812
|
+
return Math.max(1, Math.round(point.median / max * rows));
|
|
813
|
+
});
|
|
814
|
+
}
|
|
815
|
+
|
|
816
|
+
// src/sidebar/rank.ts
|
|
817
|
+
function widgetRows(samples, nowMs) {
|
|
818
|
+
const since = nowMs - WIDGET_WINDOW_MS;
|
|
819
|
+
const groups = new Map;
|
|
820
|
+
for (const sample of samples) {
|
|
821
|
+
if (sample.completedAt <= since || sample.completedAt > nowMs)
|
|
822
|
+
continue;
|
|
823
|
+
const key = rowKey(sample.providerID, sample.modelID);
|
|
824
|
+
let group = groups.get(key);
|
|
825
|
+
if (group === undefined) {
|
|
826
|
+
group = { providerID: sample.providerID, modelID: sample.modelID, rates: [] };
|
|
827
|
+
groups.set(key, group);
|
|
828
|
+
}
|
|
829
|
+
group.rates.push(sample.rate);
|
|
830
|
+
}
|
|
831
|
+
const rows = [];
|
|
832
|
+
for (const [key, group] of groups) {
|
|
833
|
+
if (group.rates.length < WIDGET_MIN_CALLS)
|
|
834
|
+
continue;
|
|
835
|
+
const value = median(group.rates);
|
|
836
|
+
if (value === null)
|
|
837
|
+
continue;
|
|
838
|
+
rows.push({
|
|
839
|
+
key,
|
|
840
|
+
providerID: group.providerID,
|
|
841
|
+
modelID: group.modelID,
|
|
842
|
+
median: value,
|
|
843
|
+
calls: group.rates.length
|
|
844
|
+
});
|
|
845
|
+
}
|
|
846
|
+
rows.sort((a, b) => {
|
|
847
|
+
const medianOrder = b.median - a.median;
|
|
848
|
+
if (medianOrder !== 0)
|
|
849
|
+
return medianOrder;
|
|
850
|
+
if (b.calls !== a.calls)
|
|
851
|
+
return b.calls - a.calls;
|
|
852
|
+
return a.key.localeCompare(b.key);
|
|
853
|
+
});
|
|
854
|
+
return rows.slice(0, WIDGET_MAX_ENTRIES);
|
|
855
|
+
}
|
|
856
|
+
var WIDGET_WINDOW_MS = 86400000;
|
|
857
|
+
var WIDGET_MIN_CALLS = 3;
|
|
858
|
+
var WIDGET_MAX_ENTRIES = 3;
|
|
859
|
+
|
|
860
|
+
// src/history/service.ts
|
|
861
|
+
var matchesScope = function(sessionDirectory, directoryFilter) {
|
|
862
|
+
if (directoryFilter === undefined)
|
|
863
|
+
return true;
|
|
864
|
+
return sessionDirectory === undefined || sessionDirectory === directoryFilter;
|
|
865
|
+
};
|
|
866
|
+
var isNotFound = function(error) {
|
|
867
|
+
if (typeof error !== "object" || error === null)
|
|
868
|
+
return false;
|
|
869
|
+
const fields = error;
|
|
870
|
+
if (fields.status === 404 || fields.statusCode === 404)
|
|
871
|
+
return true;
|
|
872
|
+
if (fields.cause?.status === 404)
|
|
873
|
+
return true;
|
|
874
|
+
return typeof fields.message === "string" && /(?:^|\D)404(?:\D|$)/.test(fields.message);
|
|
875
|
+
};
|
|
876
|
+
function createHistoryService(deps) {
|
|
877
|
+
const client = deps.client;
|
|
878
|
+
const now = deps.now;
|
|
879
|
+
const concurrency = Math.max(1, deps.concurrency ?? 8);
|
|
880
|
+
const records3 = new Map;
|
|
881
|
+
const index = new Map;
|
|
882
|
+
const tombstones = new Set;
|
|
883
|
+
const coverage = new Map;
|
|
884
|
+
const views = new Map;
|
|
885
|
+
const passes = new Map;
|
|
886
|
+
const statuses = new Map;
|
|
887
|
+
const work = new Map;
|
|
888
|
+
const dirty = new Set;
|
|
889
|
+
const scanTokens = new Map;
|
|
890
|
+
let holds = 0;
|
|
891
|
+
let timerCancel;
|
|
892
|
+
let auditCancel;
|
|
893
|
+
let burstCancel;
|
|
894
|
+
let burstStartedAt;
|
|
895
|
+
let flushInFlight;
|
|
896
|
+
let resetGeneration = 0;
|
|
897
|
+
let pendingRecords = [];
|
|
898
|
+
let persistence = "ok";
|
|
899
|
+
let widgetPublished = false;
|
|
900
|
+
let hydrated = false;
|
|
901
|
+
const storedWidget = deps.repository.readWidgetSnapshot();
|
|
902
|
+
const [widgetState, setWidgetState] = createSignal(storedWidget === undefined ? { status: "loading", rows: [], stale: false } : { status: "ready", rows: storedWidget.rows, stale: true });
|
|
903
|
+
if (storedWidget !== undefined)
|
|
904
|
+
widgetPublished = true;
|
|
905
|
+
rememberTombstones();
|
|
906
|
+
function rememberTombstones() {
|
|
907
|
+
for (const sessionID of deps.repository.loadTombstones().sessionIDs)
|
|
908
|
+
tombstones.add(sessionID);
|
|
909
|
+
}
|
|
910
|
+
function hydrateShards() {
|
|
911
|
+
if (hydrated)
|
|
912
|
+
return;
|
|
913
|
+
hydrated = true;
|
|
914
|
+
for (const shard of deps.repository.loadAllShards().values()) {
|
|
915
|
+
for (const entry of Object.values(shard.index)) {
|
|
916
|
+
if (!tombstones.has(entry.sessionID))
|
|
917
|
+
index.set(entry.sessionID, entry);
|
|
918
|
+
}
|
|
919
|
+
for (const record of Object.values(shard.records)) {
|
|
920
|
+
if (!tombstones.has(record.sessionID))
|
|
921
|
+
records3.set(record.sessionID, record);
|
|
922
|
+
}
|
|
923
|
+
}
|
|
924
|
+
}
|
|
925
|
+
function forgetSession(sessionID) {
|
|
926
|
+
records3.delete(sessionID);
|
|
927
|
+
index.delete(sessionID);
|
|
928
|
+
dirty.delete(sessionID);
|
|
929
|
+
pendingRecords = pendingRecords.filter((record) => record.sessionID !== sessionID);
|
|
930
|
+
}
|
|
931
|
+
function workOf(sessionID) {
|
|
932
|
+
const existing = work.get(sessionID);
|
|
933
|
+
if (existing !== undefined)
|
|
934
|
+
return existing;
|
|
935
|
+
const fresh = { revision: 0, covered: 0, inFlight: false, pending: false, followUp: false };
|
|
936
|
+
work.set(sessionID, fresh);
|
|
937
|
+
return fresh;
|
|
938
|
+
}
|
|
939
|
+
function scanTokenOf(sessionID) {
|
|
940
|
+
return scanTokens.get(sessionID) ?? 0;
|
|
941
|
+
}
|
|
942
|
+
function coverageFor(directory) {
|
|
943
|
+
const key = directoryKeyOf(directory);
|
|
944
|
+
const cached = coverage.get(key);
|
|
945
|
+
if (cached !== undefined)
|
|
946
|
+
return cached;
|
|
947
|
+
const stored = deps.repository.readCoverage(directory);
|
|
948
|
+
if (stored !== undefined)
|
|
949
|
+
coverage.set(key, stored);
|
|
950
|
+
return stored;
|
|
951
|
+
}
|
|
952
|
+
function statusFor(directory) {
|
|
953
|
+
const key = directoryKeyOf(directory);
|
|
954
|
+
let status = statuses.get(key);
|
|
955
|
+
if (status === undefined) {
|
|
956
|
+
status = { refreshing: false, failed: false, publishedAt: undefined, publishCancel: undefined };
|
|
957
|
+
statuses.set(key, status);
|
|
958
|
+
}
|
|
959
|
+
return status;
|
|
960
|
+
}
|
|
961
|
+
function viewsOf(directory) {
|
|
962
|
+
const matching = [];
|
|
963
|
+
for (const entry of views.values()) {
|
|
964
|
+
if (entry.request.directory === directory)
|
|
965
|
+
matching.push(entry);
|
|
966
|
+
}
|
|
967
|
+
return matching;
|
|
968
|
+
}
|
|
969
|
+
function requestedDirectories() {
|
|
970
|
+
const directories = [];
|
|
971
|
+
for (const entry of views.values()) {
|
|
972
|
+
if (!directories.some((directory) => directory === entry.request.directory)) {
|
|
973
|
+
directories.push(entry.request.directory);
|
|
974
|
+
}
|
|
975
|
+
}
|
|
976
|
+
if (directories.length === 0 && holds > 0)
|
|
977
|
+
directories.push(undefined);
|
|
978
|
+
return directories;
|
|
979
|
+
}
|
|
980
|
+
function affectedDirectories(sessionDirectory) {
|
|
981
|
+
return requestedDirectories().filter((directory) => matchesScope(sessionDirectory, directory));
|
|
982
|
+
}
|
|
983
|
+
function countIndex(directory) {
|
|
984
|
+
let count = 0;
|
|
985
|
+
for (const entry of index.values())
|
|
986
|
+
if (matchesScope(entry.directory, directory))
|
|
987
|
+
count += 1;
|
|
988
|
+
return count;
|
|
989
|
+
}
|
|
990
|
+
function liveView(request) {
|
|
991
|
+
const fromMs = rangeStartMs(request.range, now());
|
|
992
|
+
const samples = [];
|
|
993
|
+
const unavailable = [];
|
|
994
|
+
for (const entry of index.values()) {
|
|
995
|
+
if (!matchesScope(entry.directory, request.directory))
|
|
996
|
+
continue;
|
|
997
|
+
if (fromMs !== undefined && entry.updatedAt < fromMs)
|
|
998
|
+
continue;
|
|
999
|
+
const record = records3.get(entry.sessionID);
|
|
1000
|
+
if (record === undefined)
|
|
1001
|
+
continue;
|
|
1002
|
+
const inRange = inRangeSamples(record, fromMs);
|
|
1003
|
+
samples.push(...inRange.samples);
|
|
1004
|
+
unavailable.push(...inRange.unavailable);
|
|
1005
|
+
}
|
|
1006
|
+
return { samples, unavailable };
|
|
1007
|
+
}
|
|
1008
|
+
function buildState(request, kind, lastCheckedAt, refreshing, refreshFailed) {
|
|
1009
|
+
const data = liveView(request);
|
|
1010
|
+
const hasData = data.samples.length > 0 || data.unavailable.length > 0;
|
|
1011
|
+
return {
|
|
1012
|
+
kind: kind === "partial" && !hasData ? "loading" : kind,
|
|
1013
|
+
samples: data.samples,
|
|
1014
|
+
unavailable: data.unavailable,
|
|
1015
|
+
variants: collectVariants(data.samples, data.unavailable),
|
|
1016
|
+
scanned: countIndex(request.directory),
|
|
1017
|
+
lastCheckedAt,
|
|
1018
|
+
refreshing,
|
|
1019
|
+
refreshFailed,
|
|
1020
|
+
persistence
|
|
1021
|
+
};
|
|
1022
|
+
}
|
|
1023
|
+
function publishViews(directory, mode) {
|
|
1024
|
+
const status = statusFor(directory);
|
|
1025
|
+
for (const entry of viewsOf(directory)) {
|
|
1026
|
+
const kind = mode === "ready" ? "ready" : mode === "failure" ? "error" : "partial";
|
|
1027
|
+
entry.publish(buildState(entry.request, kind, entry.lastCheckedAt, mode !== "ready", mode === "failure" || status.failed));
|
|
1028
|
+
}
|
|
1029
|
+
if (mode === "failure")
|
|
1030
|
+
publishWidgetFailure();
|
|
1031
|
+
else
|
|
1032
|
+
publishWidget(mode === "ready");
|
|
1033
|
+
}
|
|
1034
|
+
function publishWidget(persist) {
|
|
1035
|
+
const nowMs = now();
|
|
1036
|
+
const rows = widgetRows(allSamples(), nowMs);
|
|
1037
|
+
widgetPublished = true;
|
|
1038
|
+
setWidgetState({ status: "ready", rows, stale: false });
|
|
1039
|
+
if (persist)
|
|
1040
|
+
persistWidget(rows, nowMs);
|
|
1041
|
+
}
|
|
1042
|
+
function publishWidgetFailure() {
|
|
1043
|
+
const current = widgetState();
|
|
1044
|
+
setWidgetState(widgetPublished ? { status: "ready", rows: current.rows, stale: true } : { status: "error", rows: [], stale: false });
|
|
1045
|
+
}
|
|
1046
|
+
async function persistWidget(rows, nowMs) {
|
|
1047
|
+
try {
|
|
1048
|
+
await deps.repository.writeWidgetSnapshot(rows, nowMs);
|
|
1049
|
+
} catch {
|
|
1050
|
+
persistence = "unavailable";
|
|
1051
|
+
}
|
|
1052
|
+
}
|
|
1053
|
+
function allSamples() {
|
|
1054
|
+
const samples = [];
|
|
1055
|
+
for (const record of records3.values())
|
|
1056
|
+
samples.push(...record.samples);
|
|
1057
|
+
return samples;
|
|
1058
|
+
}
|
|
1059
|
+
async function flushRecords() {
|
|
1060
|
+
if (pendingRecords.length === 0)
|
|
1061
|
+
return;
|
|
1062
|
+
const generation = resetGeneration;
|
|
1063
|
+
const batch = pendingRecords;
|
|
1064
|
+
pendingRecords = [];
|
|
1065
|
+
const flush = (async () => {
|
|
1066
|
+
try {
|
|
1067
|
+
await deps.repository.putRecords(batch, now());
|
|
1068
|
+
persistence = "ok";
|
|
1069
|
+
} catch {
|
|
1070
|
+
if (generation === resetGeneration)
|
|
1071
|
+
pendingRecords = [...batch, ...pendingRecords];
|
|
1072
|
+
persistence = "unavailable";
|
|
1073
|
+
}
|
|
1074
|
+
})();
|
|
1075
|
+
flushInFlight = flush;
|
|
1076
|
+
try {
|
|
1077
|
+
await flush;
|
|
1078
|
+
} finally {
|
|
1079
|
+
if (flushInFlight === flush)
|
|
1080
|
+
flushInFlight = undefined;
|
|
1081
|
+
}
|
|
1082
|
+
}
|
|
1083
|
+
async function readMeta(sessionID) {
|
|
1084
|
+
const get = client.session.get;
|
|
1085
|
+
if (get === undefined)
|
|
1086
|
+
return;
|
|
1087
|
+
try {
|
|
1088
|
+
return await get.call(client.session, { sessionID });
|
|
1089
|
+
} catch {
|
|
1090
|
+
return;
|
|
1091
|
+
}
|
|
1092
|
+
}
|
|
1093
|
+
async function scanSession(meta) {
|
|
1094
|
+
if (tombstones.has(meta.id)) {
|
|
1095
|
+
forgetSession(meta.id);
|
|
1096
|
+
return { meta: undefined, requeue: false, discarded: true };
|
|
1097
|
+
}
|
|
1098
|
+
const state = workOf(meta.id);
|
|
1099
|
+
if (state.inFlight) {
|
|
1100
|
+
state.followUp = true;
|
|
1101
|
+
return;
|
|
1102
|
+
}
|
|
1103
|
+
state.inFlight = true;
|
|
1104
|
+
const revision = state.revision;
|
|
1105
|
+
const generation = resetGeneration;
|
|
1106
|
+
const token = scanTokenOf(meta.id);
|
|
1107
|
+
const current = () => generation === resetGeneration && scanTokenOf(meta.id) === token;
|
|
1108
|
+
try {
|
|
1109
|
+
const fresh = await readMeta(meta.id) ?? meta;
|
|
1110
|
+
if (!current())
|
|
1111
|
+
return { meta: undefined, requeue: false, discarded: true };
|
|
1112
|
+
const scan = await scanMessages(client, fresh);
|
|
1113
|
+
if (!current())
|
|
1114
|
+
return { meta: undefined, requeue: false, discarded: true };
|
|
1115
|
+
const after = await readMeta(meta.id) ?? fresh;
|
|
1116
|
+
if (!current())
|
|
1117
|
+
return { meta: undefined, requeue: false, discarded: true };
|
|
1118
|
+
if (tombstones.has(fresh.id)) {
|
|
1119
|
+
forgetSession(fresh.id);
|
|
1120
|
+
return { meta: after, requeue: false, discarded: true };
|
|
1121
|
+
}
|
|
1122
|
+
const record = recordFrom(fresh, scan, now());
|
|
1123
|
+
records3.set(record.sessionID, record);
|
|
1124
|
+
index.set(record.sessionID, {
|
|
1125
|
+
sessionID: record.sessionID,
|
|
1126
|
+
directory: record.directory,
|
|
1127
|
+
updatedAt: record.updatedAt
|
|
1128
|
+
});
|
|
1129
|
+
pendingRecords.push(record);
|
|
1130
|
+
return { meta: after, requeue: signatureFor(after) !== signatureFor(fresh), discarded: false };
|
|
1131
|
+
} finally {
|
|
1132
|
+
state.inFlight = false;
|
|
1133
|
+
state.covered = Math.max(state.covered, revision);
|
|
1134
|
+
if (state.followUp || state.revision > state.covered) {
|
|
1135
|
+
state.followUp = false;
|
|
1136
|
+
scheduleSessionScan(meta.id);
|
|
1137
|
+
}
|
|
1138
|
+
}
|
|
1139
|
+
}
|
|
1140
|
+
function cancelPublish(directory) {
|
|
1141
|
+
const status = statuses.get(directoryKeyOf(directory));
|
|
1142
|
+
if (status?.publishCancel === undefined)
|
|
1143
|
+
return;
|
|
1144
|
+
status.publishCancel();
|
|
1145
|
+
status.publishCancel = undefined;
|
|
1146
|
+
}
|
|
1147
|
+
function cancelPublications() {
|
|
1148
|
+
for (const status of statuses.values()) {
|
|
1149
|
+
if (status.publishCancel === undefined)
|
|
1150
|
+
continue;
|
|
1151
|
+
status.publishCancel();
|
|
1152
|
+
status.publishCancel = undefined;
|
|
1153
|
+
}
|
|
1154
|
+
}
|
|
1155
|
+
function schedulePublish(directory) {
|
|
1156
|
+
const status = statusFor(directory);
|
|
1157
|
+
if (status.publishCancel !== undefined)
|
|
1158
|
+
return;
|
|
1159
|
+
const elapsed = now() - (status.publishedAt ?? now());
|
|
1160
|
+
status.publishCancel = deps.delay(() => {
|
|
1161
|
+
status.publishCancel = undefined;
|
|
1162
|
+
publishDeferred(directory);
|
|
1163
|
+
}, Math.max(0, PUBLISH_INTERVAL_MS - elapsed));
|
|
1164
|
+
}
|
|
1165
|
+
async function publishDeferred(directory) {
|
|
1166
|
+
try {
|
|
1167
|
+
await flushRecords();
|
|
1168
|
+
publishViews(directory, "progress");
|
|
1169
|
+
statusFor(directory).publishedAt = now();
|
|
1170
|
+
} catch {
|
|
1171
|
+
}
|
|
1172
|
+
}
|
|
1173
|
+
async function publishProgress(directory) {
|
|
1174
|
+
const status = statusFor(directory);
|
|
1175
|
+
if (status.publishedAt !== undefined && now() - status.publishedAt < PUBLISH_INTERVAL_MS) {
|
|
1176
|
+
schedulePublish(directory);
|
|
1177
|
+
return;
|
|
1178
|
+
}
|
|
1179
|
+
await flushRecords();
|
|
1180
|
+
publishViews(directory, "progress");
|
|
1181
|
+
status.publishedAt = now();
|
|
1182
|
+
}
|
|
1183
|
+
async function drain(directory, items, onRequeue) {
|
|
1184
|
+
let cursor = 0;
|
|
1185
|
+
let abandoned = false;
|
|
1186
|
+
const worker = async () => {
|
|
1187
|
+
for (;; ) {
|
|
1188
|
+
if (holds === 0) {
|
|
1189
|
+
abandoned = true;
|
|
1190
|
+
return;
|
|
1191
|
+
}
|
|
1192
|
+
const position = cursor;
|
|
1193
|
+
cursor += 1;
|
|
1194
|
+
if (position >= items.length)
|
|
1195
|
+
return;
|
|
1196
|
+
const outcome = await scanSession(items[position]);
|
|
1197
|
+
if (outcome?.requeue === true && outcome.meta !== undefined)
|
|
1198
|
+
onRequeue(outcome.meta);
|
|
1199
|
+
await publishProgress(directory);
|
|
1200
|
+
}
|
|
1201
|
+
};
|
|
1202
|
+
const workers = Math.min(concurrency, Math.max(1, items.length));
|
|
1203
|
+
await Promise.all(Array.from({ length: workers }, () => worker()));
|
|
1204
|
+
return abandoned;
|
|
1205
|
+
}
|
|
1206
|
+
async function commitCoverage(directory, startedAt, inventory, previous) {
|
|
1207
|
+
const next = {
|
|
1208
|
+
schemaVersion: CACHE_SCHEMA_VERSION,
|
|
1209
|
+
directoryFilter: directory,
|
|
1210
|
+
fullInventoryCompletedAt: inventory ? startedAt : previous?.fullInventoryCompletedAt,
|
|
1211
|
+
recentCatchUpAt: startedAt
|
|
1212
|
+
};
|
|
1213
|
+
try {
|
|
1214
|
+
await deps.repository.writeCoverage(next);
|
|
1215
|
+
coverage.set(directoryKeyOf(directory), next);
|
|
1216
|
+
} catch {
|
|
1217
|
+
persistence = "unavailable";
|
|
1218
|
+
}
|
|
1219
|
+
}
|
|
1220
|
+
async function publishReady(directory) {
|
|
1221
|
+
cancelPublish(directory);
|
|
1222
|
+
await flushRecords();
|
|
1223
|
+
const checkedAt = now();
|
|
1224
|
+
for (const entry of viewsOf(directory)) {
|
|
1225
|
+
const data = liveView(entry.request);
|
|
1226
|
+
entry.lastCheckedAt = checkedAt;
|
|
1227
|
+
const snapshot = {
|
|
1228
|
+
schemaVersion: CACHE_SCHEMA_VERSION,
|
|
1229
|
+
metricVersion: METRIC_VERSION,
|
|
1230
|
+
directoryFilter: entry.request.directory,
|
|
1231
|
+
range: entry.request.range,
|
|
1232
|
+
rows: comparisonRows(data.samples, data.unavailable),
|
|
1233
|
+
lastCheckedAt: checkedAt,
|
|
1234
|
+
savedAtMs: checkedAt
|
|
1235
|
+
};
|
|
1236
|
+
try {
|
|
1237
|
+
await deps.repository.writeViewSnapshot(snapshot);
|
|
1238
|
+
} catch {
|
|
1239
|
+
persistence = "unavailable";
|
|
1240
|
+
}
|
|
1241
|
+
}
|
|
1242
|
+
statusFor(directory).publishedAt = checkedAt;
|
|
1243
|
+
publishViews(directory, "ready");
|
|
1244
|
+
}
|
|
1245
|
+
async function probeSession(sessionID) {
|
|
1246
|
+
const get = client.session.get;
|
|
1247
|
+
if (get === undefined)
|
|
1248
|
+
return "unknown";
|
|
1249
|
+
try {
|
|
1250
|
+
await get.call(client.session, { sessionID });
|
|
1251
|
+
return "present";
|
|
1252
|
+
} catch (error) {
|
|
1253
|
+
return isNotFound(error) ? "missing" : "unknown";
|
|
1254
|
+
}
|
|
1255
|
+
}
|
|
1256
|
+
async function verifyInventory(listed, known) {
|
|
1257
|
+
if (client.session.get === undefined)
|
|
1258
|
+
return;
|
|
1259
|
+
const tombstoned = [...tombstones];
|
|
1260
|
+
let removed = false;
|
|
1261
|
+
let verified = true;
|
|
1262
|
+
for (const sessionID of known) {
|
|
1263
|
+
if (listed.has(sessionID) || tombstones.has(sessionID))
|
|
1264
|
+
continue;
|
|
1265
|
+
const state = await probeSession(sessionID);
|
|
1266
|
+
if (state === "missing") {
|
|
1267
|
+
await deleteSession(sessionID);
|
|
1268
|
+
removed = true;
|
|
1269
|
+
} else if (state === "unknown") {
|
|
1270
|
+
verified = false;
|
|
1271
|
+
}
|
|
1272
|
+
}
|
|
1273
|
+
if (removed || !verified)
|
|
1274
|
+
return;
|
|
1275
|
+
for (const sessionID of tombstoned) {
|
|
1276
|
+
if (await probeSession(sessionID) !== "missing") {
|
|
1277
|
+
verified = false;
|
|
1278
|
+
break;
|
|
1279
|
+
}
|
|
1280
|
+
}
|
|
1281
|
+
if (!verified || tombstoned.length === 0)
|
|
1282
|
+
return;
|
|
1283
|
+
try {
|
|
1284
|
+
await deps.repository.clearTombstones(now());
|
|
1285
|
+
tombstones.clear();
|
|
1286
|
+
} catch {
|
|
1287
|
+
persistence = "unavailable";
|
|
1288
|
+
}
|
|
1289
|
+
}
|
|
1290
|
+
async function deleteSession(sessionID) {
|
|
1291
|
+
scanTokens.set(sessionID, scanTokenOf(sessionID) + 1);
|
|
1292
|
+
tombstones.add(sessionID);
|
|
1293
|
+
const directory = records3.get(sessionID)?.directory ?? index.get(sessionID)?.directory;
|
|
1294
|
+
forgetSession(sessionID);
|
|
1295
|
+
try {
|
|
1296
|
+
await deps.repository.removeSessions([sessionID], now());
|
|
1297
|
+
} catch {
|
|
1298
|
+
persistence = "unavailable";
|
|
1299
|
+
}
|
|
1300
|
+
await publishSessionWork([directory], "settled");
|
|
1301
|
+
}
|
|
1302
|
+
function unsettled() {
|
|
1303
|
+
for (const state of work.values()) {
|
|
1304
|
+
if (state.inFlight || state.pending || state.followUp || state.revision > state.covered)
|
|
1305
|
+
return true;
|
|
1306
|
+
}
|
|
1307
|
+
return false;
|
|
1308
|
+
}
|
|
1309
|
+
async function publishSessionWork(sessionDirectories, mode) {
|
|
1310
|
+
const targets = new Set;
|
|
1311
|
+
for (const sessionDirectory of sessionDirectories) {
|
|
1312
|
+
for (const directory of affectedDirectories(sessionDirectory))
|
|
1313
|
+
targets.add(directory);
|
|
1314
|
+
}
|
|
1315
|
+
if (targets.size === 0) {
|
|
1316
|
+
await flushRecords();
|
|
1317
|
+
publishWidget(false);
|
|
1318
|
+
return;
|
|
1319
|
+
}
|
|
1320
|
+
for (const directory of targets) {
|
|
1321
|
+
if (mode === "settled" && !statusFor(directory).refreshing && !unsettled()) {
|
|
1322
|
+
await publishReady(directory);
|
|
1323
|
+
} else {
|
|
1324
|
+
await publishProgress(directory);
|
|
1325
|
+
}
|
|
1326
|
+
}
|
|
1327
|
+
}
|
|
1328
|
+
function publishSessionFailure(sessionDirectory) {
|
|
1329
|
+
const targets = affectedDirectories(sessionDirectory);
|
|
1330
|
+
if (targets.length === 0) {
|
|
1331
|
+
publishWidgetFailure();
|
|
1332
|
+
return;
|
|
1333
|
+
}
|
|
1334
|
+
for (const directory of targets) {
|
|
1335
|
+
const status = statusFor(directory);
|
|
1336
|
+
status.refreshing = true;
|
|
1337
|
+
status.failed = true;
|
|
1338
|
+
publishViews(directory, "failure");
|
|
1339
|
+
}
|
|
1340
|
+
}
|
|
1341
|
+
async function scanOne(sessionID) {
|
|
1342
|
+
const meta = await readMeta(sessionID);
|
|
1343
|
+
if (meta === undefined)
|
|
1344
|
+
return { scanned: false, directory: undefined };
|
|
1345
|
+
const directory = meta.location?.directory;
|
|
1346
|
+
if (tombstones.has(sessionID)) {
|
|
1347
|
+
forgetSession(sessionID);
|
|
1348
|
+
return { scanned: false, directory };
|
|
1349
|
+
}
|
|
1350
|
+
try {
|
|
1351
|
+
await scanSession(meta);
|
|
1352
|
+
return { scanned: true, directory };
|
|
1353
|
+
} catch {
|
|
1354
|
+
publishSessionFailure(directory);
|
|
1355
|
+
return { scanned: false, directory };
|
|
1356
|
+
}
|
|
1357
|
+
}
|
|
1358
|
+
function scheduleSessionScan(sessionID) {
|
|
1359
|
+
const state = workOf(sessionID);
|
|
1360
|
+
if (state.pending || state.inFlight) {
|
|
1361
|
+
if (state.revision > state.covered)
|
|
1362
|
+
state.followUp = true;
|
|
1363
|
+
return;
|
|
1364
|
+
}
|
|
1365
|
+
if (state.revision <= state.covered)
|
|
1366
|
+
return;
|
|
1367
|
+
state.pending = true;
|
|
1368
|
+
Promise.resolve().then(async () => {
|
|
1369
|
+
state.pending = false;
|
|
1370
|
+
const result = await scanOne(sessionID);
|
|
1371
|
+
if (!result.scanned)
|
|
1372
|
+
return;
|
|
1373
|
+
await publishSessionWork([result.directory], "progress");
|
|
1374
|
+
}).catch(() => {
|
|
1375
|
+
}).finally(() => {
|
|
1376
|
+
state.pending = false;
|
|
1377
|
+
});
|
|
1378
|
+
}
|
|
1379
|
+
function scheduleDirtyFlush() {
|
|
1380
|
+
if (holds === 0 || dirty.size === 0)
|
|
1381
|
+
return;
|
|
1382
|
+
const at = now();
|
|
1383
|
+
if (burstStartedAt === undefined)
|
|
1384
|
+
burstStartedAt = at;
|
|
1385
|
+
burstCancel?.();
|
|
1386
|
+
burstCancel = undefined;
|
|
1387
|
+
const remaining = Math.max(0, burstStartedAt + MAX_SCHEDULE_DELAY_MS - at);
|
|
1388
|
+
burstCancel = deps.delay(() => {
|
|
1389
|
+
burstCancel = undefined;
|
|
1390
|
+
flushDirty();
|
|
1391
|
+
}, Math.min(DIRTY_DEBOUNCE_MS, remaining));
|
|
1392
|
+
}
|
|
1393
|
+
function flushDirty() {
|
|
1394
|
+
burstStartedAt = undefined;
|
|
1395
|
+
if (holds === 0)
|
|
1396
|
+
return;
|
|
1397
|
+
const sessions = [...dirty];
|
|
1398
|
+
dirty.clear();
|
|
1399
|
+
for (const sessionID of sessions) {
|
|
1400
|
+
const state = workOf(sessionID);
|
|
1401
|
+
state.revision += 1;
|
|
1402
|
+
scheduleSessionScan(sessionID);
|
|
1403
|
+
}
|
|
1404
|
+
}
|
|
1405
|
+
function markDirty(sessionID) {
|
|
1406
|
+
if (tombstones.has(sessionID))
|
|
1407
|
+
return;
|
|
1408
|
+
dirty.add(sessionID);
|
|
1409
|
+
scheduleDirtyFlush();
|
|
1410
|
+
}
|
|
1411
|
+
function auditCandidates() {
|
|
1412
|
+
return [...index.values()].filter((entry) => !tombstones.has(entry.sessionID)).map((entry) => ({ entry, scannedAt: records3.get(entry.sessionID)?.scannedAtMs ?? 0 })).sort((left, right) => left.scannedAt - right.scannedAt || left.entry.sessionID.localeCompare(right.entry.sessionID)).slice(0, AUDIT_BATCH_SESSIONS).map((candidate) => candidate.entry.sessionID);
|
|
1413
|
+
}
|
|
1414
|
+
async function runAudit() {
|
|
1415
|
+
if (holds === 0)
|
|
1416
|
+
return;
|
|
1417
|
+
const directories = [];
|
|
1418
|
+
for (const sessionID of auditCandidates()) {
|
|
1419
|
+
if (holds === 0)
|
|
1420
|
+
break;
|
|
1421
|
+
const result = await scanOne(sessionID);
|
|
1422
|
+
if (result.scanned)
|
|
1423
|
+
directories.push(result.directory);
|
|
1424
|
+
}
|
|
1425
|
+
if (directories.length > 0)
|
|
1426
|
+
await publishSessionWork(directories, "settled");
|
|
1427
|
+
}
|
|
1428
|
+
async function runPass(directory) {
|
|
1429
|
+
hydrateShards();
|
|
1430
|
+
const status = statusFor(directory);
|
|
1431
|
+
status.refreshing = true;
|
|
1432
|
+
const startedAt = now();
|
|
1433
|
+
const generation = resetGeneration;
|
|
1434
|
+
const previous = coverageFor(directory);
|
|
1435
|
+
const inventory = previous?.fullInventoryCompletedAt === undefined || startedAt - previous.fullInventoryCompletedAt > INVENTORY_MIN_INTERVAL_MS;
|
|
1436
|
+
try {
|
|
1437
|
+
const listing = await listSessions(client, inventory || previous?.recentCatchUpAt === undefined ? { directory } : { directory, fromMs: previous.recentCatchUpAt });
|
|
1438
|
+
if (generation !== resetGeneration) {
|
|
1439
|
+
status.refreshing = true;
|
|
1440
|
+
return;
|
|
1441
|
+
}
|
|
1442
|
+
rememberTombstones();
|
|
1443
|
+
const known = [];
|
|
1444
|
+
if (inventory) {
|
|
1445
|
+
for (const entry of index.values()) {
|
|
1446
|
+
if (tombstones.has(entry.sessionID))
|
|
1447
|
+
continue;
|
|
1448
|
+
if (!matchesScope(entry.directory, directory))
|
|
1449
|
+
continue;
|
|
1450
|
+
known.push(entry.sessionID);
|
|
1451
|
+
}
|
|
1452
|
+
}
|
|
1453
|
+
const listed = new Set;
|
|
1454
|
+
const queue = [];
|
|
1455
|
+
for (const meta of listing.sessions) {
|
|
1456
|
+
listed.add(meta.id);
|
|
1457
|
+
if (tombstones.has(meta.id)) {
|
|
1458
|
+
forgetSession(meta.id);
|
|
1459
|
+
continue;
|
|
1460
|
+
}
|
|
1461
|
+
const existing = records3.get(meta.id);
|
|
1462
|
+
if (existing !== undefined && existing.signature === signatureFor(meta))
|
|
1463
|
+
continue;
|
|
1464
|
+
queue.push(meta);
|
|
1465
|
+
}
|
|
1466
|
+
if (inventory)
|
|
1467
|
+
await verifyInventory(listed, known);
|
|
1468
|
+
const requeue = [];
|
|
1469
|
+
const abandoned = await drain(directory, queue, (meta) => {
|
|
1470
|
+
if (!requeue.some((item) => item.id === meta.id))
|
|
1471
|
+
requeue.push(meta);
|
|
1472
|
+
});
|
|
1473
|
+
if (abandoned) {
|
|
1474
|
+
cancelPublish(directory);
|
|
1475
|
+
return;
|
|
1476
|
+
}
|
|
1477
|
+
const abandonedAgain = await drain(directory, requeue, () => {
|
|
1478
|
+
});
|
|
1479
|
+
if (abandonedAgain) {
|
|
1480
|
+
cancelPublish(directory);
|
|
1481
|
+
return;
|
|
1482
|
+
}
|
|
1483
|
+
if (generation !== resetGeneration) {
|
|
1484
|
+
status.refreshing = true;
|
|
1485
|
+
return;
|
|
1486
|
+
}
|
|
1487
|
+
await flushRecords();
|
|
1488
|
+
if (generation !== resetGeneration) {
|
|
1489
|
+
status.refreshing = true;
|
|
1490
|
+
return;
|
|
1491
|
+
}
|
|
1492
|
+
await commitCoverage(directory, startedAt, inventory, previous);
|
|
1493
|
+
if (generation !== resetGeneration) {
|
|
1494
|
+
status.refreshing = true;
|
|
1495
|
+
return;
|
|
1496
|
+
}
|
|
1497
|
+
status.refreshing = false;
|
|
1498
|
+
status.failed = false;
|
|
1499
|
+
await publishReady(directory);
|
|
1500
|
+
} catch {
|
|
1501
|
+
if (generation !== resetGeneration) {
|
|
1502
|
+
status.refreshing = true;
|
|
1503
|
+
return;
|
|
1504
|
+
}
|
|
1505
|
+
status.refreshing = true;
|
|
1506
|
+
status.failed = true;
|
|
1507
|
+
cancelPublish(directory);
|
|
1508
|
+
publishViews(directory, "failure");
|
|
1509
|
+
}
|
|
1510
|
+
}
|
|
1511
|
+
function ensurePass(directory) {
|
|
1512
|
+
const key = directoryKeyOf(directory);
|
|
1513
|
+
const slot = passes.get(key);
|
|
1514
|
+
if (slot?.inFlight === true) {
|
|
1515
|
+
slot.queued = true;
|
|
1516
|
+
return;
|
|
1517
|
+
}
|
|
1518
|
+
const next = { inFlight: true, queued: false };
|
|
1519
|
+
passes.set(key, next);
|
|
1520
|
+
runPass(directory).finally(() => {
|
|
1521
|
+
next.inFlight = false;
|
|
1522
|
+
if (next.queued) {
|
|
1523
|
+
next.queued = false;
|
|
1524
|
+
ensurePass(directory);
|
|
1525
|
+
}
|
|
1526
|
+
});
|
|
1527
|
+
}
|
|
1528
|
+
function schedulePass(directory) {
|
|
1529
|
+
if (holds === 0)
|
|
1530
|
+
return;
|
|
1531
|
+
Promise.resolve().then(() => {
|
|
1532
|
+
if (holds === 0 || !requestedDirectories().some((requested) => requested === directory))
|
|
1533
|
+
return;
|
|
1534
|
+
ensurePass(directory);
|
|
1535
|
+
});
|
|
1536
|
+
}
|
|
1537
|
+
function startTimers() {
|
|
1538
|
+
if (timerCancel !== undefined)
|
|
1539
|
+
return;
|
|
1540
|
+
timerCancel = deps.setTimer(() => {
|
|
1541
|
+
if (holds === 0)
|
|
111
1542
|
return;
|
|
112
|
-
const
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
1543
|
+
for (const directory of requestedDirectories())
|
|
1544
|
+
ensurePass(directory);
|
|
1545
|
+
}, RECENT_CATCHUP_MS);
|
|
1546
|
+
auditCancel = deps.setTimer(() => {
|
|
1547
|
+
runAudit().catch(() => {
|
|
1548
|
+
});
|
|
1549
|
+
}, AUDIT_INTERVAL_MS);
|
|
1550
|
+
scheduleDirtyFlush();
|
|
1551
|
+
for (const directory of requestedDirectories())
|
|
1552
|
+
schedulePass(directory);
|
|
1553
|
+
}
|
|
1554
|
+
function stopTimers() {
|
|
1555
|
+
cancelPublications();
|
|
1556
|
+
burstCancel?.();
|
|
1557
|
+
burstCancel = undefined;
|
|
1558
|
+
burstStartedAt = undefined;
|
|
1559
|
+
if (auditCancel !== undefined) {
|
|
1560
|
+
auditCancel();
|
|
1561
|
+
auditCancel = undefined;
|
|
131
1562
|
}
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
for (const sample of samples)
|
|
136
|
-
if (sample.variant !== undefined)
|
|
137
|
-
variantSet.add(sample.variant);
|
|
138
|
-
for (const sample of unavailable)
|
|
139
|
-
if (sample.variant !== undefined)
|
|
140
|
-
variantSet.add(sample.variant);
|
|
141
|
-
return { samples, unavailable, variants: [...variantSet].sort() };
|
|
142
|
-
}
|
|
143
|
-
var SESSION_PAGE_SIZE = 100;
|
|
144
|
-
var MESSAGE_PAGE_SIZE = 200;
|
|
145
|
-
var DEFAULT_CONCURRENCY = 8;
|
|
146
|
-
|
|
147
|
-
// src/stats.ts
|
|
148
|
-
function median(values) {
|
|
149
|
-
if (values.length === 0)
|
|
150
|
-
return null;
|
|
151
|
-
const sorted = [...values].sort((a, b) => a - b);
|
|
152
|
-
const middle = Math.floor(sorted.length / 2);
|
|
153
|
-
if (sorted.length % 2 === 1)
|
|
154
|
-
return sorted[middle];
|
|
155
|
-
return (sorted[middle - 1] + sorted[middle]) / 2;
|
|
156
|
-
}
|
|
157
|
-
function applyReasoningFilter(samples, unavailable, filter) {
|
|
158
|
-
if (filter === "all")
|
|
159
|
-
return { samples, unavailable };
|
|
160
|
-
const matches = (variant) => filter === "unknown" ? variant === undefined : variant === filter;
|
|
161
|
-
return {
|
|
162
|
-
samples: samples.filter((sample) => matches(sample.variant)),
|
|
163
|
-
unavailable: unavailable.filter((sample) => matches(sample.variant))
|
|
164
|
-
};
|
|
165
|
-
}
|
|
166
|
-
function rowKey(providerID, modelID) {
|
|
167
|
-
return `${providerID}/${modelID}`;
|
|
168
|
-
}
|
|
169
|
-
function comparisonRows(samples, unavailable) {
|
|
170
|
-
const groups = new Map;
|
|
171
|
-
const ensure = (providerID, modelID) => {
|
|
172
|
-
const key = rowKey(providerID, modelID);
|
|
173
|
-
let group = groups.get(key);
|
|
174
|
-
if (group === undefined) {
|
|
175
|
-
group = { providerID, modelID, rates: [], unavailable: 0 };
|
|
176
|
-
groups.set(key, group);
|
|
1563
|
+
if (timerCancel !== undefined) {
|
|
1564
|
+
timerCancel();
|
|
1565
|
+
timerCancel = undefined;
|
|
177
1566
|
}
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
const
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
1567
|
+
}
|
|
1568
|
+
function view(request) {
|
|
1569
|
+
const key = viewKeyOf(request);
|
|
1570
|
+
const existing = views.get(key);
|
|
1571
|
+
if (existing !== undefined)
|
|
1572
|
+
return existing.accessor;
|
|
1573
|
+
const snapshot = deps.repository.readViewSnapshot(request.directory, request.range);
|
|
1574
|
+
const lastCheckedAt = snapshot?.lastCheckedAt;
|
|
1575
|
+
hydrateShards();
|
|
1576
|
+
const [state, setState] = createSignal(buildState(request, snapshot === undefined ? "loading" : "cached", lastCheckedAt, true, false));
|
|
1577
|
+
views.set(key, { request, accessor: state, publish: setState, lastCheckedAt });
|
|
1578
|
+
schedulePass(request.directory);
|
|
1579
|
+
return state;
|
|
1580
|
+
}
|
|
1581
|
+
function hold() {
|
|
1582
|
+
holds += 1;
|
|
1583
|
+
if (holds === 1)
|
|
1584
|
+
startTimers();
|
|
1585
|
+
let released = false;
|
|
1586
|
+
return () => {
|
|
1587
|
+
if (released)
|
|
1588
|
+
return;
|
|
1589
|
+
released = true;
|
|
1590
|
+
holds -= 1;
|
|
1591
|
+
if (holds === 0)
|
|
1592
|
+
stopTimers();
|
|
193
1593
|
};
|
|
194
|
-
});
|
|
195
|
-
return rows.sort((a, b) => {
|
|
196
|
-
const unavailableOrder = Number(a.unavailable) - Number(b.unavailable);
|
|
197
|
-
if (unavailableOrder !== 0)
|
|
198
|
-
return unavailableOrder;
|
|
199
|
-
const medianOrder = (b.median ?? Number.NEGATIVE_INFINITY) - (a.median ?? Number.NEGATIVE_INFINITY);
|
|
200
|
-
if (medianOrder !== 0)
|
|
201
|
-
return medianOrder;
|
|
202
|
-
if (b.calls !== a.calls)
|
|
203
|
-
return b.calls - a.calls;
|
|
204
|
-
return a.key.localeCompare(b.key);
|
|
205
|
-
});
|
|
206
|
-
}
|
|
207
|
-
var dayStart = function(epochMs) {
|
|
208
|
-
const date = new Date(epochMs);
|
|
209
|
-
return new Date(date.getFullYear(), date.getMonth(), date.getDate());
|
|
210
|
-
};
|
|
211
|
-
function localDayKey(epochMs) {
|
|
212
|
-
const date = new Date(epochMs);
|
|
213
|
-
const month = String(date.getMonth() + 1).padStart(2, "0");
|
|
214
|
-
const day = String(date.getDate()).padStart(2, "0");
|
|
215
|
-
return `${date.getFullYear()}-${month}-${day}`;
|
|
216
|
-
}
|
|
217
|
-
function dailySeries(samples, key, fromMs, nowMs) {
|
|
218
|
-
const matching = samples.filter((sample) => rowKey(sample.providerID, sample.modelID) === key);
|
|
219
|
-
const startMs = fromMs ?? (matching.length > 0 ? Math.min(...matching.map((sample) => sample.completedAt)) : nowMs);
|
|
220
|
-
const byDay = new Map;
|
|
221
|
-
for (const sample of matching) {
|
|
222
|
-
const day = localDayKey(sample.completedAt);
|
|
223
|
-
const rates = byDay.get(day);
|
|
224
|
-
if (rates === undefined)
|
|
225
|
-
byDay.set(day, [sample.rate]);
|
|
226
|
-
else
|
|
227
|
-
rates.push(sample.rate);
|
|
228
1594
|
}
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
1595
|
+
function refreshNow() {
|
|
1596
|
+
for (const directory of requestedDirectories())
|
|
1597
|
+
ensurePass(directory);
|
|
1598
|
+
}
|
|
1599
|
+
async function reset() {
|
|
1600
|
+
resetGeneration += 1;
|
|
1601
|
+
cancelPublications();
|
|
1602
|
+
burstCancel?.();
|
|
1603
|
+
burstCancel = undefined;
|
|
1604
|
+
burstStartedAt = undefined;
|
|
1605
|
+
dirty.clear();
|
|
1606
|
+
records3.clear();
|
|
1607
|
+
index.clear();
|
|
1608
|
+
tombstones.clear();
|
|
1609
|
+
coverage.clear();
|
|
1610
|
+
pendingRecords = [];
|
|
1611
|
+
widgetPublished = false;
|
|
1612
|
+
setWidgetState({ status: "loading", rows: [], stale: false });
|
|
1613
|
+
for (const status of statuses.values()) {
|
|
1614
|
+
status.refreshing = true;
|
|
1615
|
+
status.failed = false;
|
|
1616
|
+
status.publishedAt = undefined;
|
|
1617
|
+
}
|
|
1618
|
+
for (const entry of views.values()) {
|
|
1619
|
+
entry.lastCheckedAt = undefined;
|
|
1620
|
+
entry.publish(buildState(entry.request, "loading", undefined, true, false));
|
|
1621
|
+
}
|
|
1622
|
+
try {
|
|
1623
|
+
await flushInFlight;
|
|
1624
|
+
await deps.repository.clear();
|
|
1625
|
+
} catch {
|
|
1626
|
+
persistence = "unavailable";
|
|
1627
|
+
}
|
|
1628
|
+
for (const directory of requestedDirectories())
|
|
1629
|
+
ensurePass(directory);
|
|
1630
|
+
}
|
|
1631
|
+
function subscribeToEvents() {
|
|
1632
|
+
deps.subscribeEvents((event) => {
|
|
1633
|
+
const sessionID = event.data?.sessionID;
|
|
1634
|
+
if (typeof sessionID !== "string" || sessionID.length === 0)
|
|
1635
|
+
return;
|
|
1636
|
+
if (event.type === DELETED_EVENT_TYPE) {
|
|
1637
|
+
deleteSession(sessionID).catch(() => {
|
|
1638
|
+
});
|
|
1639
|
+
return;
|
|
1640
|
+
}
|
|
1641
|
+
if (!DIRTY_EVENT_TYPES.has(event.type))
|
|
1642
|
+
return;
|
|
1643
|
+
markDirty(sessionID);
|
|
238
1644
|
});
|
|
239
1645
|
}
|
|
240
|
-
|
|
1646
|
+
subscribeToEvents();
|
|
1647
|
+
return { view, widget: () => widgetState, hold, refreshNow, reset };
|
|
241
1648
|
}
|
|
242
|
-
|
|
243
|
-
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
1649
|
+
var DIRTY_DEBOUNCE_MS = 250;
|
|
1650
|
+
var MAX_SCHEDULE_DELAY_MS = 1000;
|
|
1651
|
+
var PUBLISH_INTERVAL_MS = 250;
|
|
1652
|
+
var RECENT_CATCHUP_MS = 60000;
|
|
1653
|
+
var INVENTORY_MIN_INTERVAL_MS = 600000;
|
|
1654
|
+
var AUDIT_INTERVAL_MS = 60000;
|
|
1655
|
+
var AUDIT_BATCH_SESSIONS = 20;
|
|
1656
|
+
var DIRTY_EVENT_TYPES = new Set([
|
|
1657
|
+
"session.step.ended",
|
|
1658
|
+
"session.step.failed",
|
|
1659
|
+
"session.execution.succeeded",
|
|
1660
|
+
"session.execution.failed",
|
|
1661
|
+
"session.execution.interrupted",
|
|
1662
|
+
"session.created",
|
|
1663
|
+
"session.forked",
|
|
1664
|
+
"session.moved",
|
|
1665
|
+
"session.revert.staged",
|
|
1666
|
+
"session.revert.committed",
|
|
1667
|
+
"session.compaction.ended",
|
|
1668
|
+
"session.compaction.failed",
|
|
1669
|
+
"session.usage.recorded"
|
|
1670
|
+
]);
|
|
1671
|
+
var DELETED_EVENT_TYPE = "session.deleted";
|
|
1672
|
+
var viewKeyOf = (request) => JSON.stringify([request.directory, request.range]);
|
|
1673
|
+
var directoryKeyOf = (directory) => JSON.stringify(directory ?? null);
|
|
1674
|
+
|
|
1675
|
+
// src/page/tokscope.tsx
|
|
1676
|
+
import {effect as _$effect5} from "@opentui/solid";
|
|
1677
|
+
import {insertNode as _$insertNode5} from "@opentui/solid";
|
|
1678
|
+
import {insert as _$insert5} from "@opentui/solid";
|
|
1679
|
+
import {createComponent as _$createComponent3} from "@opentui/solid";
|
|
1680
|
+
import {setProp as _$setProp5} from "@opentui/solid";
|
|
1681
|
+
import {createElement as _$createElement5} from "@opentui/solid";
|
|
1682
|
+
import {useTerminalDimensions} from "@opentui/solid";
|
|
1683
|
+
import {createEffect, createMemo as createMemo2, createSignal as createSignal2, Match, Show as Show3, Switch} from "solid-js";
|
|
1684
|
+
|
|
1685
|
+
// src/format.ts
|
|
1686
|
+
function formatRate(median2) {
|
|
1687
|
+
return `${median2.toFixed(1)} tok/s`;
|
|
249
1688
|
}
|
|
250
|
-
function
|
|
251
|
-
|
|
1689
|
+
function formatDayLabel(date) {
|
|
1690
|
+
const [year, month, day] = date.split("-").map(Number);
|
|
1691
|
+
return new Intl.DateTimeFormat("en-US", { month: "short", day: "numeric" }).format(new Date(year, month - 1, day));
|
|
252
1692
|
}
|
|
253
|
-
function
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
1693
|
+
function formatCoverage(measured, unavailable) {
|
|
1694
|
+
return unavailable > 0 ? `${measured} measured calls; ${unavailable} unavailable` : `${measured} measured calls`;
|
|
1695
|
+
}
|
|
1696
|
+
function formatHm(ms) {
|
|
1697
|
+
const date = new Date(ms);
|
|
1698
|
+
return `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
|
|
1699
|
+
}
|
|
1700
|
+
function modelDisplayName(models, providerID, modelID) {
|
|
1701
|
+
const match = models?.find((model) => model.id === modelID && model.providerID === providerID);
|
|
1702
|
+
return match?.name ?? `${providerID}/${modelID}`;
|
|
260
1703
|
}
|
|
261
1704
|
|
|
262
1705
|
// src/page/header.tsx
|
|
@@ -319,6 +1762,48 @@ function Header(props) {
|
|
|
319
1762
|
})();
|
|
320
1763
|
}
|
|
321
1764
|
|
|
1765
|
+
// src/page/heading-status.ts
|
|
1766
|
+
var withPersistence = function(message, view) {
|
|
1767
|
+
return view.persistence === "unavailable" ? message + NOT_SAVED_SUFFIX : message;
|
|
1768
|
+
};
|
|
1769
|
+
var hasData = function(view) {
|
|
1770
|
+
return view.samples.length > 0 || view.unavailable.length > 0;
|
|
1771
|
+
};
|
|
1772
|
+
function partialMessage(view) {
|
|
1773
|
+
return withPersistence("History loading \u2014 results incomplete", view);
|
|
1774
|
+
}
|
|
1775
|
+
function cachedMessage(view) {
|
|
1776
|
+
const base = view.lastCheckedAt === undefined ? "Cached \xB7 refreshing\u2026" : `Cached \xB7 last checked ${formatHm(view.lastCheckedAt)} \xB7 refreshing\u2026`;
|
|
1777
|
+
return withPersistence(base, view);
|
|
1778
|
+
}
|
|
1779
|
+
function refreshFailedMessage(view) {
|
|
1780
|
+
return withPersistence("Refresh failed \u2014 showing cached results", view);
|
|
1781
|
+
}
|
|
1782
|
+
function bannerMessage(view) {
|
|
1783
|
+
switch (view.kind) {
|
|
1784
|
+
case "partial":
|
|
1785
|
+
return partialMessage(view);
|
|
1786
|
+
case "cached":
|
|
1787
|
+
return cachedMessage(view);
|
|
1788
|
+
case "error":
|
|
1789
|
+
return hasData(view) ? refreshFailedMessage(view) : undefined;
|
|
1790
|
+
default:
|
|
1791
|
+
return;
|
|
1792
|
+
}
|
|
1793
|
+
}
|
|
1794
|
+
function footerStatusSuffix(view) {
|
|
1795
|
+
switch (view.kind) {
|
|
1796
|
+
case "ready":
|
|
1797
|
+
return view.lastCheckedAt === undefined ? SHARED_CACHE_SUFFIX : ` \xB7 checked ${formatHm(view.lastCheckedAt)}${SHARED_CACHE_SUFFIX}`;
|
|
1798
|
+
case "cached":
|
|
1799
|
+
return SHARED_CACHE_SUFFIX;
|
|
1800
|
+
default:
|
|
1801
|
+
return "";
|
|
1802
|
+
}
|
|
1803
|
+
}
|
|
1804
|
+
var NOT_SAVED_SUFFIX = " \xB7 Cache not saved";
|
|
1805
|
+
var SHARED_CACHE_SUFFIX = " \xB7 cache: shared";
|
|
1806
|
+
|
|
322
1807
|
// src/page/selection.ts
|
|
323
1808
|
function nextSelection(keys, current, delta) {
|
|
324
1809
|
if (keys.length === 0)
|
|
@@ -344,6 +1829,14 @@ function pickPageState(result, samples, unavailable) {
|
|
|
344
1829
|
return "unmeasurable";
|
|
345
1830
|
return "empty";
|
|
346
1831
|
}
|
|
1832
|
+
function pickViewPageState(view) {
|
|
1833
|
+
if (view.kind === "loading")
|
|
1834
|
+
return "loading";
|
|
1835
|
+
const content = pickPageState({ error: undefined }, view.samples, view.unavailable);
|
|
1836
|
+
if (view.kind === "error" && content === "empty")
|
|
1837
|
+
return "error";
|
|
1838
|
+
return content;
|
|
1839
|
+
}
|
|
347
1840
|
|
|
348
1841
|
// src/page/states.tsx
|
|
349
1842
|
import {createTextNode as _$createTextNode2} from "@opentui/solid";
|
|
@@ -661,46 +2154,26 @@ function TrendPanel(props) {
|
|
|
661
2154
|
function TokscopePage(props) {
|
|
662
2155
|
const theme = props.context.theme;
|
|
663
2156
|
const dimensions = useTerminalDimensions();
|
|
664
|
-
const openedAt = Date.now();
|
|
665
2157
|
props.context.data.location.model.sync();
|
|
666
2158
|
props.context.data.location.provider.sync();
|
|
667
|
-
const [
|
|
2159
|
+
const [filters3, setFilters] = createSignal2({
|
|
668
2160
|
...DEFAULT_FILTERS
|
|
669
2161
|
});
|
|
670
|
-
const [
|
|
671
|
-
const [
|
|
672
|
-
const [selectedDay, setSelectedDay] = createSignal(0);
|
|
2162
|
+
const [selectedKey, setSelectedKey] = createSignal2(undefined);
|
|
2163
|
+
const [selectedDay, setSelectedDay] = createSignal2(0);
|
|
673
2164
|
const directory = () => props.context.location?.directory ?? props.context.data.location.default().directory;
|
|
674
|
-
const
|
|
675
|
-
|
|
676
|
-
|
|
677
|
-
|
|
678
|
-
|
|
679
|
-
|
|
680
|
-
|
|
681
|
-
fromMs: rangeStartMs(range, openedAt),
|
|
682
|
-
onProgress: (info) => setScanned(info.sessionsScanned)
|
|
683
|
-
});
|
|
684
|
-
});
|
|
685
|
-
const filtered = createMemo2(() => {
|
|
686
|
-
const value = result();
|
|
687
|
-
if (value === undefined)
|
|
688
|
-
return {
|
|
689
|
-
samples: [],
|
|
690
|
-
unavailable: []
|
|
691
|
-
};
|
|
692
|
-
return applyReasoningFilter(value.samples, value.unavailable, filters2().reasoning);
|
|
693
|
-
});
|
|
694
|
-
const pageState = createMemo2(() => {
|
|
695
|
-
if (result.loading)
|
|
696
|
-
return "loading";
|
|
697
|
-
return pickPageState({
|
|
698
|
-
error: result.error
|
|
699
|
-
}, filtered().samples, filtered().unavailable);
|
|
700
|
-
});
|
|
2165
|
+
const state2 = () => props.service.view({
|
|
2166
|
+
directory: filters3().scope === "project" ? directory() : undefined,
|
|
2167
|
+
range: filters3().range
|
|
2168
|
+
})();
|
|
2169
|
+
const referenceNow = () => state2().lastCheckedAt ?? Date.now();
|
|
2170
|
+
const filtered = createMemo2(() => applyReasoningFilter(state2().samples, state2().unavailable, filters3().reasoning));
|
|
2171
|
+
const pageState = createMemo2(() => pickViewPageState(state2()));
|
|
701
2172
|
const rows = createMemo2(() => comparisonRows(filtered().samples, filtered().unavailable));
|
|
702
2173
|
createEffect(() => {
|
|
703
2174
|
const list = rows();
|
|
2175
|
+
if (list.some((row) => row.key === selectedKey()))
|
|
2176
|
+
return;
|
|
704
2177
|
setSelectedKey(list[0]?.key);
|
|
705
2178
|
});
|
|
706
2179
|
const moveSelection = (delta) => setSelectedKey(nextSelection(rows().map((row) => row.key), selectedKey(), delta));
|
|
@@ -709,13 +2182,19 @@ function TokscopePage(props) {
|
|
|
709
2182
|
const key = selectedKey();
|
|
710
2183
|
if (key === undefined)
|
|
711
2184
|
return [];
|
|
712
|
-
|
|
2185
|
+
const nowMs = referenceNow();
|
|
2186
|
+
return dailySeries(filtered().samples, key, rangeStartMs(filters3().range, nowMs), nowMs);
|
|
713
2187
|
});
|
|
2188
|
+
let anchoredKey;
|
|
714
2189
|
createEffect(() => {
|
|
715
|
-
selectedKey();
|
|
2190
|
+
const key = selectedKey();
|
|
716
2191
|
const points = series();
|
|
2192
|
+
const current = selectedDay();
|
|
2193
|
+
if (key === anchoredKey && current < points.length)
|
|
2194
|
+
return;
|
|
717
2195
|
const last = points.findLastIndex((point) => point.calls > 0);
|
|
718
2196
|
setSelectedDay(last === -1 ? Math.max(0, points.length - 1) : last);
|
|
2197
|
+
anchoredKey = key;
|
|
719
2198
|
});
|
|
720
2199
|
const moveDay = (delta) => setSelectedDay((current) => Math.max(0, Math.min(current + delta, Math.max(0, series().length - 1))));
|
|
721
2200
|
const rowLabel = () => {
|
|
@@ -731,13 +2210,13 @@ function TokscopePage(props) {
|
|
|
731
2210
|
title: "All settings",
|
|
732
2211
|
value: "all"
|
|
733
2212
|
}];
|
|
734
|
-
const value =
|
|
735
|
-
for (const variant of value
|
|
2213
|
+
const value = state2();
|
|
2214
|
+
for (const variant of value.variants)
|
|
736
2215
|
options.push({
|
|
737
2216
|
title: variant,
|
|
738
2217
|
value: variant
|
|
739
2218
|
});
|
|
740
|
-
const hasUnknown =
|
|
2219
|
+
const hasUnknown = [...value.samples, ...value.unavailable].some((item) => item.variant === undefined);
|
|
741
2220
|
if (hasUnknown)
|
|
742
2221
|
options.push({
|
|
743
2222
|
title: "unknown",
|
|
@@ -748,7 +2227,7 @@ function TokscopePage(props) {
|
|
|
748
2227
|
const pickScope = async () => {
|
|
749
2228
|
const chosen = await props.context.ui.dialog.select({
|
|
750
2229
|
title: "Scope",
|
|
751
|
-
current:
|
|
2230
|
+
current: filters3().scope,
|
|
752
2231
|
options: SCOPE_OPTIONS
|
|
753
2232
|
});
|
|
754
2233
|
if (chosen !== undefined)
|
|
@@ -760,7 +2239,7 @@ function TokscopePage(props) {
|
|
|
760
2239
|
const pickRange = async () => {
|
|
761
2240
|
const chosen = await props.context.ui.dialog.select({
|
|
762
2241
|
title: "Time range",
|
|
763
|
-
current:
|
|
2242
|
+
current: filters3().range,
|
|
764
2243
|
options: RANGE_OPTIONS
|
|
765
2244
|
});
|
|
766
2245
|
if (chosen !== undefined)
|
|
@@ -772,7 +2251,7 @@ function TokscopePage(props) {
|
|
|
772
2251
|
const pickReasoning = async () => {
|
|
773
2252
|
const chosen = await props.context.ui.dialog.select({
|
|
774
2253
|
title: "Reasoning setting",
|
|
775
|
-
current:
|
|
2254
|
+
current: filters3().reasoning,
|
|
776
2255
|
options: reasoningOptions()
|
|
777
2256
|
});
|
|
778
2257
|
if (chosen !== undefined)
|
|
@@ -826,8 +2305,8 @@ function TokscopePage(props) {
|
|
|
826
2305
|
bind: "enter",
|
|
827
2306
|
title: "retry",
|
|
828
2307
|
run: () => {
|
|
829
|
-
if (
|
|
830
|
-
|
|
2308
|
+
if (state2().kind === "error")
|
|
2309
|
+
props.service.refreshNow();
|
|
831
2310
|
}
|
|
832
2311
|
}]
|
|
833
2312
|
}));
|
|
@@ -846,9 +2325,20 @@ function TokscopePage(props) {
|
|
|
846
2325
|
return props.context;
|
|
847
2326
|
},
|
|
848
2327
|
get filters() {
|
|
849
|
-
return
|
|
2328
|
+
return filters3();
|
|
850
2329
|
}
|
|
851
2330
|
}), _el$2);
|
|
2331
|
+
_$insert5(_el$, _$createComponent3(Show3, {
|
|
2332
|
+
get when() {
|
|
2333
|
+
return bannerMessage(state2());
|
|
2334
|
+
},
|
|
2335
|
+
children: (message) => (() => {
|
|
2336
|
+
var _el$5 = _$createElement5("text");
|
|
2337
|
+
_$insert5(_el$5, message);
|
|
2338
|
+
_$effect5((_$p) => _$setProp5(_el$5, "fg", state2().kind === "error" ? theme.text.feedback.error.base : theme.text.muted, _$p));
|
|
2339
|
+
return _el$5;
|
|
2340
|
+
})()
|
|
2341
|
+
}), _el$2);
|
|
852
2342
|
_$setProp5(_el$2, "flexGrow", 1);
|
|
853
2343
|
_$setProp5(_el$2, "flexDirection", "column");
|
|
854
2344
|
_$setProp5(_el$2, "gap", 1);
|
|
@@ -864,7 +2354,7 @@ function TokscopePage(props) {
|
|
|
864
2354
|
return props.context;
|
|
865
2355
|
},
|
|
866
2356
|
get sessions() {
|
|
867
|
-
return
|
|
2357
|
+
return state2().scanned;
|
|
868
2358
|
}
|
|
869
2359
|
});
|
|
870
2360
|
}
|
|
@@ -889,7 +2379,7 @@ function TokscopePage(props) {
|
|
|
889
2379
|
return props.context;
|
|
890
2380
|
},
|
|
891
2381
|
get filters() {
|
|
892
|
-
return
|
|
2382
|
+
return filters3();
|
|
893
2383
|
}
|
|
894
2384
|
});
|
|
895
2385
|
}
|
|
@@ -944,10 +2434,10 @@ function TokscopePage(props) {
|
|
|
944
2434
|
return rowLabel();
|
|
945
2435
|
},
|
|
946
2436
|
get rangeLabel() {
|
|
947
|
-
return rangeLabel(
|
|
2437
|
+
return rangeLabel(filters3().range);
|
|
948
2438
|
},
|
|
949
2439
|
get reasoningLabel() {
|
|
950
|
-
return reasoningLabel(
|
|
2440
|
+
return reasoningLabel(filters3().reasoning);
|
|
951
2441
|
},
|
|
952
2442
|
get width() {
|
|
953
2443
|
return Math.max(20, dimensions().width - 2);
|
|
@@ -958,7 +2448,7 @@ function TokscopePage(props) {
|
|
|
958
2448
|
})];
|
|
959
2449
|
}
|
|
960
2450
|
}));
|
|
961
|
-
_$insert5(_el$4, () =>
|
|
2451
|
+
_$insert5(_el$4, () => HELP_LINE + coverage() + footerStatusSuffix(state2()));
|
|
962
2452
|
_$effect5((_p$) => {
|
|
963
2453
|
var _v$ = theme.background.base, _v$2 = theme.text.muted;
|
|
964
2454
|
_v$ !== _p$.e && (_p$.e = _$setProp5(_el$, "backgroundColor", _v$, _p$.e));
|
|
@@ -991,104 +2481,16 @@ var RANGE_OPTIONS = [{
|
|
|
991
2481
|
title: "All history",
|
|
992
2482
|
value: "all"
|
|
993
2483
|
}];
|
|
2484
|
+
var HELP_LINE = "\u2191\u2193 select \xB7 enter trend \xB7 \u2190\u2192 day \xB7 s scope \xB7 t range \xB7 r reasoning \xB7 esc back \xB7 reset history in palette";
|
|
994
2485
|
|
|
995
2486
|
// src/sidebar/store.ts
|
|
996
|
-
|
|
997
|
-
|
|
998
|
-
|
|
999
|
-
|
|
1000
|
-
|
|
1001
|
-
|
|
1002
|
-
for (const sample of samples) {
|
|
1003
|
-
if (sample.completedAt <= since || sample.completedAt > nowMs)
|
|
1004
|
-
continue;
|
|
1005
|
-
const key = rowKey(sample.providerID, sample.modelID);
|
|
1006
|
-
let group = groups.get(key);
|
|
1007
|
-
if (group === undefined) {
|
|
1008
|
-
group = { providerID: sample.providerID, modelID: sample.modelID, rates: [] };
|
|
1009
|
-
groups.set(key, group);
|
|
1010
|
-
}
|
|
1011
|
-
group.rates.push(sample.rate);
|
|
1012
|
-
}
|
|
1013
|
-
const rows = [];
|
|
1014
|
-
for (const [key, group] of groups) {
|
|
1015
|
-
if (group.rates.length < WIDGET_MIN_CALLS)
|
|
1016
|
-
continue;
|
|
1017
|
-
const value = median(group.rates);
|
|
1018
|
-
if (value === null)
|
|
1019
|
-
continue;
|
|
1020
|
-
rows.push({
|
|
1021
|
-
key,
|
|
1022
|
-
providerID: group.providerID,
|
|
1023
|
-
modelID: group.modelID,
|
|
1024
|
-
median: value,
|
|
1025
|
-
calls: group.rates.length
|
|
1026
|
-
});
|
|
1027
|
-
}
|
|
1028
|
-
rows.sort((a, b) => {
|
|
1029
|
-
const medianOrder = b.median - a.median;
|
|
1030
|
-
if (medianOrder !== 0)
|
|
1031
|
-
return medianOrder;
|
|
1032
|
-
if (b.calls !== a.calls)
|
|
1033
|
-
return b.calls - a.calls;
|
|
1034
|
-
return a.key.localeCompare(b.key);
|
|
1035
|
-
});
|
|
1036
|
-
return rows.slice(0, WIDGET_MAX_ENTRIES);
|
|
1037
|
-
}
|
|
1038
|
-
var WIDGET_WINDOW_MS = 86400000;
|
|
1039
|
-
var WIDGET_MIN_CALLS = 3;
|
|
1040
|
-
var WIDGET_MAX_ENTRIES = 3;
|
|
1041
|
-
|
|
1042
|
-
// src/sidebar/store.ts
|
|
1043
|
-
function createWidgetStore(deps) {
|
|
1044
|
-
const [state2, setState] = createSignal2({ status: "loading", rows: [], stale: false });
|
|
1045
|
-
let inFlight = false;
|
|
1046
|
-
let pending = false;
|
|
1047
|
-
let resolvers = [];
|
|
1048
|
-
async function runOnce() {
|
|
1049
|
-
const nowMs = deps.now();
|
|
1050
|
-
try {
|
|
1051
|
-
const result = await collectMeasurements(deps.client, { fromMs: nowMs - WIDGET_WINDOW_MS });
|
|
1052
|
-
setState({ status: "ready", rows: widgetRows(result.samples, nowMs), stale: false });
|
|
1053
|
-
} catch {
|
|
1054
|
-
const previous = state2();
|
|
1055
|
-
setState(previous.rows.length > 0 ? { status: "ready", rows: previous.rows, stale: true } : { status: "error", rows: [], stale: false });
|
|
1056
|
-
}
|
|
1057
|
-
}
|
|
1058
|
-
async function drain() {
|
|
1059
|
-
inFlight = true;
|
|
1060
|
-
do {
|
|
1061
|
-
pending = false;
|
|
1062
|
-
await runOnce();
|
|
1063
|
-
} while (pending);
|
|
1064
|
-
inFlight = false;
|
|
1065
|
-
const waiting = resolvers;
|
|
1066
|
-
resolvers = [];
|
|
1067
|
-
for (const resolve of waiting)
|
|
1068
|
-
resolve();
|
|
1069
|
-
}
|
|
1070
|
-
function refresh() {
|
|
1071
|
-
return new Promise((resolve) => {
|
|
1072
|
-
resolvers.push(resolve);
|
|
1073
|
-
if (inFlight) {
|
|
1074
|
-
pending = true;
|
|
1075
|
-
return;
|
|
1076
|
-
}
|
|
1077
|
-
drain();
|
|
1078
|
-
});
|
|
1079
|
-
}
|
|
1080
|
-
function attach() {
|
|
1081
|
-
const detachEvent = deps.onEvent(() => void refresh());
|
|
1082
|
-
const detachTimer = deps.setTimer(() => void refresh(), WIDGET_REFRESH_MS);
|
|
1083
|
-
refresh();
|
|
1084
|
-
return () => {
|
|
1085
|
-
detachEvent();
|
|
1086
|
-
detachTimer();
|
|
1087
|
-
};
|
|
1088
|
-
}
|
|
1089
|
-
return { state: state2, refresh, attach };
|
|
2487
|
+
function createWidgetStore(service) {
|
|
2488
|
+
return {
|
|
2489
|
+
state: () => service.widget()(),
|
|
2490
|
+
refresh: () => service.refreshNow(),
|
|
2491
|
+
attach: () => service.hold()
|
|
2492
|
+
};
|
|
1090
2493
|
}
|
|
1091
|
-
var WIDGET_REFRESH_MS = 60000;
|
|
1092
2494
|
|
|
1093
2495
|
// src/sidebar/widget.tsx
|
|
1094
2496
|
import {insertNode as _$insertNode6} from "@opentui/solid";
|
|
@@ -1100,7 +2502,7 @@ import {use as _$use} from "@opentui/solid";
|
|
|
1100
2502
|
import {createElement as _$createElement6} from "@opentui/solid";
|
|
1101
2503
|
import {TextAttributes as TextAttributes4} from "@opentui/core";
|
|
1102
2504
|
import {useTerminalDimensions as useTerminalDimensions2} from "@opentui/solid";
|
|
1103
|
-
import {createEffect as createEffect2, createMemo as createMemo3, createSignal as createSignal3, For as For3, onCleanup, onMount, Show as
|
|
2505
|
+
import {createEffect as createEffect2, createMemo as createMemo3, createSignal as createSignal3, For as For3, onCleanup, onMount, Show as Show4} from "solid-js";
|
|
1104
2506
|
|
|
1105
2507
|
// src/sidebar/layout.ts
|
|
1106
2508
|
var unitLine = function(width) {
|
|
@@ -1260,7 +2662,7 @@ function TokscopeSidebar(props) {
|
|
|
1260
2662
|
}, _el$);
|
|
1261
2663
|
_$setProp6(_el$, "flexDirection", "column");
|
|
1262
2664
|
_$setProp6(_el$, "width", "100%");
|
|
1263
|
-
_$insert6(_el$, _$createComponent4(
|
|
2665
|
+
_$insert6(_el$, _$createComponent4(Show4, {
|
|
1264
2666
|
get when() {
|
|
1265
2667
|
return view2();
|
|
1266
2668
|
},
|
|
@@ -1294,7 +2696,7 @@ function TokscopeSidebar(props) {
|
|
|
1294
2696
|
_$effect6((_$p) => _$setProp6(_el$7, "fg", theme.text.muted, _$p));
|
|
1295
2697
|
return _el$7;
|
|
1296
2698
|
})()
|
|
1297
|
-
}), _$createComponent4(
|
|
2699
|
+
}), _$createComponent4(Show4, {
|
|
1298
2700
|
get when() {
|
|
1299
2701
|
return current.status === "loading";
|
|
1300
2702
|
},
|
|
@@ -1304,7 +2706,7 @@ function TokscopeSidebar(props) {
|
|
|
1304
2706
|
_$effect6((_$p) => _$setProp6(_el$2, "fg", theme.text.muted, _$p));
|
|
1305
2707
|
return _el$2;
|
|
1306
2708
|
}
|
|
1307
|
-
}), _$createComponent4(
|
|
2709
|
+
}), _$createComponent4(Show4, {
|
|
1308
2710
|
get when() {
|
|
1309
2711
|
return current.status === "error";
|
|
1310
2712
|
},
|
|
@@ -1314,12 +2716,12 @@ function TokscopeSidebar(props) {
|
|
|
1314
2716
|
_$effect6((_$p) => _$setProp6(_el$3, "fg", theme.text.feedback.error.base, _$p));
|
|
1315
2717
|
return _el$3;
|
|
1316
2718
|
}
|
|
1317
|
-
}), _$createComponent4(
|
|
2719
|
+
}), _$createComponent4(Show4, {
|
|
1318
2720
|
get when() {
|
|
1319
2721
|
return current.status === "ready";
|
|
1320
2722
|
},
|
|
1321
2723
|
get children() {
|
|
1322
|
-
return _$createComponent4(
|
|
2724
|
+
return _$createComponent4(Show4, {
|
|
1323
2725
|
get when() {
|
|
1324
2726
|
return current.lines.length > 0;
|
|
1325
2727
|
},
|
|
@@ -1377,19 +2779,36 @@ var tui_default = Plugin.define({
|
|
|
1377
2779
|
name: "tokscope"
|
|
1378
2780
|
});
|
|
1379
2781
|
};
|
|
1380
|
-
|
|
2782
|
+
let unsubscribeEvents;
|
|
2783
|
+
const service2 = createHistoryService({
|
|
1381
2784
|
client: context.client,
|
|
1382
|
-
|
|
2785
|
+
repository: createRepository(createPluginDurableStore(context.storage)),
|
|
2786
|
+
subscribeEvents: (handler) => {
|
|
2787
|
+
unsubscribeEvents = context.data.listen(({
|
|
2788
|
+
details
|
|
2789
|
+
}) => handler({
|
|
2790
|
+
type: details.type,
|
|
2791
|
+
data: details.data
|
|
2792
|
+
}));
|
|
2793
|
+
return unsubscribeEvents;
|
|
2794
|
+
},
|
|
1383
2795
|
setTimer: (callback, ms) => {
|
|
1384
2796
|
const id = setInterval(callback, ms);
|
|
1385
2797
|
return () => clearInterval(id);
|
|
1386
2798
|
},
|
|
2799
|
+
delay: (callback, ms) => {
|
|
2800
|
+
const id = setTimeout(callback, ms);
|
|
2801
|
+
return () => clearTimeout(id);
|
|
2802
|
+
},
|
|
1387
2803
|
now: () => Date.now()
|
|
1388
2804
|
});
|
|
2805
|
+
const release = service2.hold();
|
|
2806
|
+
const store3 = createWidgetStore(service2);
|
|
1389
2807
|
context.ui.router.register({
|
|
1390
2808
|
name: "tokscope",
|
|
1391
2809
|
render: () => _$createComponent5(TokscopePage, {
|
|
1392
2810
|
context,
|
|
2811
|
+
service: service2,
|
|
1393
2812
|
onClose: () => context.ui.router.navigate(previous())
|
|
1394
2813
|
})
|
|
1395
2814
|
});
|
|
@@ -1397,7 +2816,7 @@ var tui_default = Plugin.define({
|
|
|
1397
2816
|
append: "sidebar.content",
|
|
1398
2817
|
render: () => _$createComponent5(TokscopeSidebar, {
|
|
1399
2818
|
context,
|
|
1400
|
-
store:
|
|
2819
|
+
store: store3,
|
|
1401
2820
|
open: openTokscope
|
|
1402
2821
|
})
|
|
1403
2822
|
});
|
|
@@ -1415,11 +2834,32 @@ var tui_default = Plugin.define({
|
|
|
1415
2834
|
},
|
|
1416
2835
|
palette: true,
|
|
1417
2836
|
run: openTokscope
|
|
2837
|
+
}, {
|
|
2838
|
+
id: "tokscope.resetHistory",
|
|
2839
|
+
title: "Tokscope: reset history cache",
|
|
2840
|
+
group: "System",
|
|
2841
|
+
palette: true,
|
|
2842
|
+
run: async () => {
|
|
2843
|
+
const confirmed = await context.ui.dialog.confirm({
|
|
2844
|
+
title: "Reset Tokscope history cache",
|
|
2845
|
+
message: "Delete the shared Tokscope history cache and rebuild it from the server?",
|
|
2846
|
+
label: {
|
|
2847
|
+
confirm: "Reset",
|
|
2848
|
+
cancel: "Cancel"
|
|
2849
|
+
}
|
|
2850
|
+
});
|
|
2851
|
+
if (confirmed === true)
|
|
2852
|
+
await service2.reset();
|
|
2853
|
+
}
|
|
1418
2854
|
}]
|
|
1419
2855
|
}));
|
|
1420
2856
|
return null;
|
|
1421
2857
|
}
|
|
1422
2858
|
});
|
|
2859
|
+
return () => {
|
|
2860
|
+
unsubscribeEvents?.();
|
|
2861
|
+
release();
|
|
2862
|
+
};
|
|
1423
2863
|
}
|
|
1424
2864
|
});
|
|
1425
2865
|
export {
|