opencode-windows-scheduler 1.0.0 → 1.1.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/CHANGELOG.md +14 -7
- package/README.md +2 -2
- package/README.ru.md +2 -2
- package/ROADMAP.md +11 -8
- package/dist/core/analytics.d.ts +119 -0
- package/dist/core/analytics.d.ts.map +1 -0
- package/dist/core/analytics.js +265 -0
- package/dist/core/retention.d.ts +29 -0
- package/dist/core/retention.d.ts.map +1 -0
- package/dist/core/retention.js +98 -0
- package/dist/db/history-repo.d.ts +33 -0
- package/dist/db/history-repo.d.ts.map +1 -1
- package/dist/db/history-repo.js +65 -0
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +85 -3
- package/dist/rpc.d.ts +134 -0
- package/dist/rpc.d.ts.map +1 -1
- package/dist/rpc.js +61 -0
- package/dist/server.d.ts.map +1 -1
- package/dist/server.js +195 -5
- package/dist/settings.d.ts +23 -0
- package/dist/settings.d.ts.map +1 -1
- package/dist/settings.js +41 -0
- package/dist/version.d.ts +8 -0
- package/dist/version.d.ts.map +1 -0
- package/dist/version.js +27 -0
- package/docs/ARCHITECTURE.md +13 -1
- package/docs/FEATURES.md +17 -5
- package/gui-experimental.cjs +2 -2
- package/package.json +4 -2
- package/src/core/analytics.ts +378 -0
- package/src/core/retention.ts +141 -0
- package/src/db/history-repo.ts +93 -0
- package/src/gui.tsx +2868 -2725
- package/src/index.ts +100 -4
- package/src/rpc.ts +66 -0
- package/src/server.ts +221 -5
- package/src/settings.ts +71 -0
- package/src/version.ts +27 -0
- package/dist/gui-experimental.cjs +0 -1
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "opencode-windows-scheduler",
|
|
3
|
-
"version": "1.
|
|
3
|
+
"version": "1.1.0",
|
|
4
4
|
"description": "Local-first scheduling and orchestration for OpenCode v2 agent jobs: cron, DAG pipelines, matrix fan-out, quality gates and observability. Free and open source (MIT).",
|
|
5
5
|
"license": "MIT",
|
|
6
6
|
"author": "opencode-windows-scheduler contributors",
|
|
@@ -62,7 +62,7 @@
|
|
|
62
62
|
"demo": "node scripts/demo-dashboard.mjs",
|
|
63
63
|
"prepare": "npm run build",
|
|
64
64
|
"prepublishOnly": "npm run build && npm run build:gui",
|
|
65
|
-
"test": "node test-sqlite.mjs && node test-crash-recovery.mjs && node test-workspaces.mjs && node test-role-scoped.mjs && node test-dry-run.mjs && node test-matrix.mjs && node test-matrix-lifecycle.mjs && node test-matrix-sync.mjs && node test-agent-tools.mjs && node test-skill.mjs && node test-docs.mjs",
|
|
65
|
+
"test": "node test-sqlite.mjs && node test-crash-recovery.mjs && node test-workspaces.mjs && node test-role-scoped.mjs && node test-dry-run.mjs && node test-matrix.mjs && node test-matrix-lifecycle.mjs && node test-matrix-sync.mjs && node test-retention.mjs && node test-metrics.mjs && node test-agent-tools.mjs && node test-skill.mjs && node test-docs.mjs",
|
|
66
66
|
"test:sqlite": "node test-sqlite.mjs",
|
|
67
67
|
"test:crash": "node test-crash-recovery.mjs",
|
|
68
68
|
"test:workspaces": "node test-workspaces.mjs",
|
|
@@ -71,6 +71,8 @@
|
|
|
71
71
|
"test:matrix": "node test-matrix.mjs",
|
|
72
72
|
"test:matrix-lifecycle": "node test-matrix-lifecycle.mjs",
|
|
73
73
|
"test:matrix-sync": "node test-matrix-sync.mjs",
|
|
74
|
+
"test:retention": "node test-retention.mjs",
|
|
75
|
+
"test:metrics": "node test-metrics.mjs",
|
|
74
76
|
"test:agent": "node test-agent-tools.mjs",
|
|
75
77
|
"test:skill": "node test-skill.mjs",
|
|
76
78
|
"test:docs": "node test-docs.mjs"
|
|
@@ -0,0 +1,378 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Аналитика по истории запусков (Спринт 18).
|
|
3
|
+
*
|
|
4
|
+
* Чистые функции без БД и HTTP: дашборд и RPC отдают JSON, экспорт — CSV.
|
|
5
|
+
* Так агрегаты легко тестировать без запуска сервера.
|
|
6
|
+
*/
|
|
7
|
+
|
|
8
|
+
/** Оценка стоимости, если запись истории не содержит costUsd. */
|
|
9
|
+
export const ESTIMATED_COST_PER_1K_TOKENS_USD = 0.003;
|
|
10
|
+
|
|
11
|
+
/** Минимальный вид записи истории, нужный аналитике. */
|
|
12
|
+
export interface AnalyticsRecord {
|
|
13
|
+
taskName: string;
|
|
14
|
+
status: string;
|
|
15
|
+
startedAt: string;
|
|
16
|
+
finishedAt?: string | null;
|
|
17
|
+
durationMs?: number | null;
|
|
18
|
+
error?: string | null;
|
|
19
|
+
tokens?: number;
|
|
20
|
+
costUsd?: number;
|
|
21
|
+
model?: string;
|
|
22
|
+
workspaceId?: string | null;
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
/** Описание задачи для группировки по матрицам. */
|
|
26
|
+
export interface AnalyticsTaskRef {
|
|
27
|
+
name: string;
|
|
28
|
+
matrixParentId?: string | null;
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
export interface DailyBucket {
|
|
32
|
+
/** YYYY-MM-DD (UTC). */
|
|
33
|
+
date: string;
|
|
34
|
+
total: number;
|
|
35
|
+
success: number;
|
|
36
|
+
error: number;
|
|
37
|
+
partial: number;
|
|
38
|
+
tokens: number;
|
|
39
|
+
costUsd: number;
|
|
40
|
+
avgDurationMs: number;
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
export interface TaskAnalyticsRow {
|
|
44
|
+
taskName: string;
|
|
45
|
+
total: number;
|
|
46
|
+
success: number;
|
|
47
|
+
error: number;
|
|
48
|
+
/** Процент успешных запусков (0..100, один знак после запятой). */
|
|
49
|
+
successRate: number;
|
|
50
|
+
avgDurationMs: number;
|
|
51
|
+
tokens: number;
|
|
52
|
+
costUsd: number;
|
|
53
|
+
/** Задача — клон матрицы (matrixParentId задан). */
|
|
54
|
+
isMatrixClone: boolean;
|
|
55
|
+
matrixParentId: string | null;
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
export interface MatrixAnalyticsRow {
|
|
59
|
+
parentId: string;
|
|
60
|
+
clones: number;
|
|
61
|
+
total: number;
|
|
62
|
+
success: number;
|
|
63
|
+
error: number;
|
|
64
|
+
successRate: number;
|
|
65
|
+
tokens: number;
|
|
66
|
+
costUsd: number;
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
export interface ModelAnalyticsRow {
|
|
70
|
+
model: string;
|
|
71
|
+
total: number;
|
|
72
|
+
costUsd: number;
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
export interface AnalyticsReport {
|
|
76
|
+
generatedAt: string;
|
|
77
|
+
/** Окно анализа в днях. */
|
|
78
|
+
windowDays: number;
|
|
79
|
+
totals: {
|
|
80
|
+
total: number;
|
|
81
|
+
success: number;
|
|
82
|
+
error: number;
|
|
83
|
+
partial: number;
|
|
84
|
+
successRate: number;
|
|
85
|
+
avgDurationMs: number;
|
|
86
|
+
tokens: number;
|
|
87
|
+
costUsd: number;
|
|
88
|
+
};
|
|
89
|
+
daily: DailyBucket[];
|
|
90
|
+
tasks: TaskAnalyticsRow[];
|
|
91
|
+
topByCost: TaskAnalyticsRow[];
|
|
92
|
+
matrices: MatrixAnalyticsRow[];
|
|
93
|
+
byModel: ModelAnalyticsRow[];
|
|
94
|
+
sources: {
|
|
95
|
+
historyRecords: number;
|
|
96
|
+
/** Сколько записей попало в окно. */
|
|
97
|
+
recordsInWindow: number;
|
|
98
|
+
/** Ограничение по количеству строк в топах. */
|
|
99
|
+
topLimit: number;
|
|
100
|
+
};
|
|
101
|
+
}
|
|
102
|
+
|
|
103
|
+
export interface BuildAnalyticsOptions {
|
|
104
|
+
/** Окно анализа в днях (по умолчанию 14). */
|
|
105
|
+
days?: number;
|
|
106
|
+
/** Опорный момент (для тестов). */
|
|
107
|
+
now?: Date;
|
|
108
|
+
/** Сколько строк оставлять в топах (по умолчанию 10). */
|
|
109
|
+
topLimit?: number;
|
|
110
|
+
/** Известные задачи — нужны для группировки матриц. */
|
|
111
|
+
tasks?: AnalyticsTaskRef[];
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
function toNumber(value: unknown): number {
|
|
115
|
+
const n = Number(value);
|
|
116
|
+
return Number.isFinite(n) && n > 0 ? n : 0;
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
/** Стоимость записи: явная цена, иначе оценка по токенам. */
|
|
120
|
+
export function recordCost(record: AnalyticsRecord): number {
|
|
121
|
+
const cost = toNumber(record.costUsd);
|
|
122
|
+
if (cost > 0) return cost;
|
|
123
|
+
const tokens = toNumber(record.tokens);
|
|
124
|
+
return tokens > 0 ? (tokens / 1000) * ESTIMATED_COST_PER_1K_TOKENS_USD : 0;
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
/** Дата записи в UTC-формате YYYY-MM-DD. */
|
|
128
|
+
export function recordDate(record: AnalyticsRecord): string {
|
|
129
|
+
const time = new Date(record.startedAt).getTime();
|
|
130
|
+
if (!Number.isFinite(time)) return "";
|
|
131
|
+
return new Date(time).toISOString().slice(0, 10);
|
|
132
|
+
}
|
|
133
|
+
|
|
134
|
+
function utcDayKey(date: Date): string {
|
|
135
|
+
return date.toISOString().slice(0, 10);
|
|
136
|
+
}
|
|
137
|
+
|
|
138
|
+
function percent(part: number, total: number): number {
|
|
139
|
+
if (total <= 0) return 0;
|
|
140
|
+
return Math.round((part / total) * 1000) / 10;
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
/**
|
|
144
|
+
* Строит отчёт по истории: итоги, дневные бакеты, разбивка по задачам,
|
|
145
|
+
* матрицам и моделям.
|
|
146
|
+
*/
|
|
147
|
+
export function buildAnalytics(
|
|
148
|
+
records: AnalyticsRecord[],
|
|
149
|
+
options: BuildAnalyticsOptions = {}
|
|
150
|
+
): AnalyticsReport {
|
|
151
|
+
const windowDays = Math.max(1, Math.floor(options.days ?? 14));
|
|
152
|
+
const topLimit = Math.max(1, Math.floor(options.topLimit ?? 10));
|
|
153
|
+
const now = options.now ?? new Date();
|
|
154
|
+
|
|
155
|
+
const dayKeys: string[] = [];
|
|
156
|
+
const dayBuckets = new Map<string, DailyBucket>();
|
|
157
|
+
for (let i = windowDays - 1; i >= 0; i -= 1) {
|
|
158
|
+
const key = utcDayKey(new Date(now.getTime() - i * 24 * 60 * 60 * 1000));
|
|
159
|
+
dayKeys.push(key);
|
|
160
|
+
dayBuckets.set(key, {
|
|
161
|
+
date: key,
|
|
162
|
+
total: 0,
|
|
163
|
+
success: 0,
|
|
164
|
+
error: 0,
|
|
165
|
+
partial: 0,
|
|
166
|
+
tokens: 0,
|
|
167
|
+
costUsd: 0,
|
|
168
|
+
avgDurationMs: 0,
|
|
169
|
+
});
|
|
170
|
+
}
|
|
171
|
+
|
|
172
|
+
const byTask = new Map<string, TaskAnalyticsRow>();
|
|
173
|
+
const byModel = new Map<string, ModelAnalyticsRow>();
|
|
174
|
+
const cloneParent = new Map<string, string>();
|
|
175
|
+
for (const task of options.tasks ?? []) {
|
|
176
|
+
const parentId = task.matrixParentId?.trim();
|
|
177
|
+
if (parentId) cloneParent.set(task.name.toLowerCase(), parentId);
|
|
178
|
+
}
|
|
179
|
+
|
|
180
|
+
let totalsTotal = 0;
|
|
181
|
+
let totalsSuccess = 0;
|
|
182
|
+
let totalsError = 0;
|
|
183
|
+
let totalsPartial = 0;
|
|
184
|
+
let totalsTokens = 0;
|
|
185
|
+
let totalsCost = 0;
|
|
186
|
+
let durationsSum = 0;
|
|
187
|
+
let durationsCount = 0;
|
|
188
|
+
let recordsInWindow = 0;
|
|
189
|
+
|
|
190
|
+
for (const record of records) {
|
|
191
|
+
const date = recordDate(record);
|
|
192
|
+
if (!date) continue;
|
|
193
|
+
const bucket = dayBuckets.get(date);
|
|
194
|
+
// Итоги считаются только по окну — это «аналитика за период».
|
|
195
|
+
if (!bucket) continue;
|
|
196
|
+
recordsInWindow += 1;
|
|
197
|
+
|
|
198
|
+
const tokens = toNumber(record.tokens);
|
|
199
|
+
const cost = recordCost(record);
|
|
200
|
+
const status = String(record.status ?? "");
|
|
201
|
+
// Незавершённые запуски не участвуют в аналитике: их ещё нельзя оценить.
|
|
202
|
+
if (status === "running") continue;
|
|
203
|
+
const duration = toNumber(record.durationMs);
|
|
204
|
+
|
|
205
|
+
bucket.total += 1;
|
|
206
|
+
bucket.tokens += tokens;
|
|
207
|
+
bucket.costUsd += cost;
|
|
208
|
+
if (status === "success") bucket.success += 1;
|
|
209
|
+
else if (status === "partial") bucket.partial += 1;
|
|
210
|
+
else bucket.error += 1;
|
|
211
|
+
if (duration > 0) {
|
|
212
|
+
bucket.avgDurationMs =
|
|
213
|
+
(bucket.avgDurationMs * (bucket.total - 1) + duration) / bucket.total;
|
|
214
|
+
}
|
|
215
|
+
|
|
216
|
+
totalsTotal += 1;
|
|
217
|
+
totalsTokens += tokens;
|
|
218
|
+
totalsCost += cost;
|
|
219
|
+
if (status === "success") totalsSuccess += 1;
|
|
220
|
+
else if (status === "partial") totalsPartial += 1;
|
|
221
|
+
else totalsError += 1;
|
|
222
|
+
if (duration > 0) {
|
|
223
|
+
durationsSum += duration;
|
|
224
|
+
durationsCount += 1;
|
|
225
|
+
}
|
|
226
|
+
|
|
227
|
+
const taskKey = record.taskName.toLowerCase();
|
|
228
|
+
const existing = byTask.get(taskKey) ?? {
|
|
229
|
+
taskName: record.taskName,
|
|
230
|
+
total: 0,
|
|
231
|
+
success: 0,
|
|
232
|
+
error: 0,
|
|
233
|
+
successRate: 0,
|
|
234
|
+
avgDurationMs: 0,
|
|
235
|
+
tokens: 0,
|
|
236
|
+
costUsd: 0,
|
|
237
|
+
isMatrixClone: cloneParent.has(taskKey),
|
|
238
|
+
matrixParentId: cloneParent.get(taskKey) ?? null,
|
|
239
|
+
};
|
|
240
|
+
existing.total += 1;
|
|
241
|
+
if (status === "success") existing.success += 1;
|
|
242
|
+
else existing.error += 1;
|
|
243
|
+
existing.tokens += tokens;
|
|
244
|
+
existing.costUsd += cost;
|
|
245
|
+
if (duration > 0) {
|
|
246
|
+
existing.avgDurationMs =
|
|
247
|
+
(existing.avgDurationMs * (existing.total - 1) + duration) / existing.total;
|
|
248
|
+
}
|
|
249
|
+
byTask.set(taskKey, existing);
|
|
250
|
+
|
|
251
|
+
const model = record.model?.trim() || "(default)";
|
|
252
|
+
const modelRow = byModel.get(model) ?? { model, total: 0, costUsd: 0 };
|
|
253
|
+
modelRow.total += 1;
|
|
254
|
+
modelRow.costUsd += cost;
|
|
255
|
+
byModel.set(model, modelRow);
|
|
256
|
+
}
|
|
257
|
+
|
|
258
|
+
const tasks = [...byTask.values()]
|
|
259
|
+
.map((row) => ({
|
|
260
|
+
...row,
|
|
261
|
+
successRate: percent(row.success, row.total),
|
|
262
|
+
avgDurationMs: Math.round(row.avgDurationMs),
|
|
263
|
+
costUsd: Math.round(row.costUsd * 1e6) / 1e6,
|
|
264
|
+
}))
|
|
265
|
+
.sort((a, b) => b.total - a.total || a.taskName.localeCompare(b.taskName));
|
|
266
|
+
|
|
267
|
+
const matrices = new Map<string, MatrixAnalyticsRow>();
|
|
268
|
+
for (const row of tasks) {
|
|
269
|
+
if (!row.matrixParentId) continue;
|
|
270
|
+
const key = row.matrixParentId.toLowerCase();
|
|
271
|
+
const matrix = matrices.get(key) ?? {
|
|
272
|
+
parentId: row.matrixParentId,
|
|
273
|
+
clones: 0,
|
|
274
|
+
total: 0,
|
|
275
|
+
success: 0,
|
|
276
|
+
error: 0,
|
|
277
|
+
successRate: 0,
|
|
278
|
+
tokens: 0,
|
|
279
|
+
costUsd: 0,
|
|
280
|
+
};
|
|
281
|
+
matrix.clones += 1;
|
|
282
|
+
matrix.total += row.total;
|
|
283
|
+
matrix.success += row.success;
|
|
284
|
+
matrix.error += row.error;
|
|
285
|
+
matrix.tokens += row.tokens;
|
|
286
|
+
matrix.costUsd += row.costUsd;
|
|
287
|
+
matrices.set(key, matrix);
|
|
288
|
+
}
|
|
289
|
+
|
|
290
|
+
const daily = dayKeys.map((key) => {
|
|
291
|
+
const bucket = dayBuckets.get(key)!;
|
|
292
|
+
return {
|
|
293
|
+
...bucket,
|
|
294
|
+
avgDurationMs: Math.round(bucket.avgDurationMs),
|
|
295
|
+
costUsd: Math.round(bucket.costUsd * 1e6) / 1e6,
|
|
296
|
+
};
|
|
297
|
+
});
|
|
298
|
+
|
|
299
|
+
return {
|
|
300
|
+
generatedAt: new Date().toISOString(),
|
|
301
|
+
windowDays,
|
|
302
|
+
totals: {
|
|
303
|
+
total: totalsTotal,
|
|
304
|
+
success: totalsSuccess,
|
|
305
|
+
error: totalsError,
|
|
306
|
+
partial: totalsPartial,
|
|
307
|
+
successRate: percent(totalsSuccess, totalsTotal),
|
|
308
|
+
avgDurationMs: durationsCount > 0 ? Math.round(durationsSum / durationsCount) : 0,
|
|
309
|
+
tokens: totalsTokens,
|
|
310
|
+
costUsd: Math.round(totalsCost * 1e6) / 1e6,
|
|
311
|
+
},
|
|
312
|
+
daily,
|
|
313
|
+
tasks,
|
|
314
|
+
topByCost: [...tasks].sort((a, b) => b.costUsd - a.costUsd).slice(0, topLimit),
|
|
315
|
+
matrices: [...matrices.values()]
|
|
316
|
+
.map((row) => ({
|
|
317
|
+
...row,
|
|
318
|
+
successRate: percent(row.success, row.total),
|
|
319
|
+
costUsd: Math.round(row.costUsd * 1e6) / 1e6,
|
|
320
|
+
}))
|
|
321
|
+
.sort((a, b) => b.costUsd - a.costUsd),
|
|
322
|
+
byModel: [...byModel.values()]
|
|
323
|
+
.map((row) => ({ ...row, costUsd: Math.round(row.costUsd * 1e6) / 1e6 }))
|
|
324
|
+
.sort((a, b) => b.costUsd - a.costUsd),
|
|
325
|
+
sources: {
|
|
326
|
+
historyRecords: records.length,
|
|
327
|
+
recordsInWindow,
|
|
328
|
+
topLimit,
|
|
329
|
+
},
|
|
330
|
+
};
|
|
331
|
+
}
|
|
332
|
+
|
|
333
|
+
/** Экранирование значения для CSV (RFC 4180). */
|
|
334
|
+
export function csvCell(value: unknown): string {
|
|
335
|
+
if (value === null || value === undefined) return "";
|
|
336
|
+
const text = String(value);
|
|
337
|
+
if (/[",\r\n;]/.test(text)) return `"${text.replace(/"/g, '""')}"`;
|
|
338
|
+
return text;
|
|
339
|
+
}
|
|
340
|
+
|
|
341
|
+
/** Заголовок CSV-экспорта истории. */
|
|
342
|
+
export const HISTORY_CSV_HEADER = [
|
|
343
|
+
"startedAt",
|
|
344
|
+
"finishedAt",
|
|
345
|
+
"taskName",
|
|
346
|
+
"status",
|
|
347
|
+
"durationMs",
|
|
348
|
+
"tokens",
|
|
349
|
+
"costUsd",
|
|
350
|
+
"model",
|
|
351
|
+
"workspaceId",
|
|
352
|
+
"error",
|
|
353
|
+
] as const;
|
|
354
|
+
|
|
355
|
+
/** История в CSV: точки с запятой как разделитель — дружелюбно к Excel (RU). */
|
|
356
|
+
export function historyToCsv(records: AnalyticsRecord[]): string {
|
|
357
|
+
const rows = [HISTORY_CSV_HEADER.join(";")];
|
|
358
|
+
for (const record of records) {
|
|
359
|
+
rows.push(
|
|
360
|
+
[
|
|
361
|
+
record.startedAt,
|
|
362
|
+
record.finishedAt ?? "",
|
|
363
|
+
record.taskName,
|
|
364
|
+
record.status,
|
|
365
|
+
record.durationMs ?? "",
|
|
366
|
+
record.tokens ?? "",
|
|
367
|
+
record.costUsd ?? "",
|
|
368
|
+
record.model ?? "",
|
|
369
|
+
record.workspaceId ?? "",
|
|
370
|
+
record.error ?? "",
|
|
371
|
+
]
|
|
372
|
+
.map(csvCell)
|
|
373
|
+
.join(";")
|
|
374
|
+
);
|
|
375
|
+
}
|
|
376
|
+
// BOM, чтобы Excel корректно открыл UTF-8 с кириллицей.
|
|
377
|
+
return `\uFEFF${rows.join("\r\n")}`;
|
|
378
|
+
}
|
|
@@ -0,0 +1,141 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Ретеншн истории (Спринт 18).
|
|
3
|
+
*
|
|
4
|
+
* Раз в сутки (и по запросу `cleanup_history`) плагин чистит сырую историю
|
|
5
|
+
* запусков: удаляет записи старше `history.retentionDays` и всё, что выходит
|
|
6
|
+
* за `history.maxRecords`. Агрегированные метрики (таблица metrics) при этом
|
|
7
|
+
* не меняются — «Всего запусков» и суммарная стоимость остаются корректными.
|
|
8
|
+
*
|
|
9
|
+
* Очистка никогда не удаляет незавершённые запуски (`finished_at IS NULL`):
|
|
10
|
+
* их обрабатывает crash recovery.
|
|
11
|
+
*/
|
|
12
|
+
import {
|
|
13
|
+
defaultHistorySettings,
|
|
14
|
+
loadSettings,
|
|
15
|
+
saveSettings,
|
|
16
|
+
type HistorySettings,
|
|
17
|
+
} from "../settings.js";
|
|
18
|
+
import {
|
|
19
|
+
countHistory,
|
|
20
|
+
pruneHistory,
|
|
21
|
+
vacuumHistory,
|
|
22
|
+
type PruneHistoryResult,
|
|
23
|
+
} from "../db/history-repo.js";
|
|
24
|
+
|
|
25
|
+
/** Период автоочистки: раз в сутки. */
|
|
26
|
+
export const CLEANUP_INTERVAL_MS = 24 * 60 * 60 * 1000;
|
|
27
|
+
|
|
28
|
+
/** Переопределения лимитов для одного прогона `cleanup_history`. */
|
|
29
|
+
export interface RetentionOverrides {
|
|
30
|
+
retentionDays?: number;
|
|
31
|
+
maxRecords?: number;
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
export interface RetentionReport extends PruneHistoryResult {
|
|
35
|
+
retentionDays: number;
|
|
36
|
+
maxRecords: number;
|
|
37
|
+
/** Удалось ли выполнить PRAGMA incremental_vacuum. */
|
|
38
|
+
vacuumed: boolean;
|
|
39
|
+
/** Причина, по которой очистка пропущена (лимиты выключены). */
|
|
40
|
+
skipped: string | null;
|
|
41
|
+
ranAt: string;
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
/** Приводит переопределение к безопасному целому (>= 0) или undefined. */
|
|
45
|
+
function normalizeOverride(value: unknown): number | undefined {
|
|
46
|
+
if (value === undefined || value === null) return undefined;
|
|
47
|
+
const n = Number(value);
|
|
48
|
+
if (!Number.isFinite(n)) return undefined;
|
|
49
|
+
const int = Math.floor(n);
|
|
50
|
+
return int >= 0 ? int : undefined;
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
function effectiveLimits(
|
|
54
|
+
settings: HistorySettings,
|
|
55
|
+
overrides: RetentionOverrides
|
|
56
|
+
): { retentionDays: number; maxRecords: number } {
|
|
57
|
+
return {
|
|
58
|
+
retentionDays:
|
|
59
|
+
normalizeOverride(overrides.retentionDays) ?? settings.retentionDays,
|
|
60
|
+
maxRecords: normalizeOverride(overrides.maxRecords) ?? settings.maxRecords,
|
|
61
|
+
};
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
/**
|
|
65
|
+
* Выполняет очистку истории по текущим настройкам.
|
|
66
|
+
* Переопределения (если переданы) сохраняются в settings.json — так
|
|
67
|
+
* `cleanup_history` заодно настраивает ретеншн.
|
|
68
|
+
*/
|
|
69
|
+
export async function runHistoryRetention(
|
|
70
|
+
overrides: RetentionOverrides = {}
|
|
71
|
+
): Promise<RetentionReport> {
|
|
72
|
+
const settings = await loadSettings();
|
|
73
|
+
const base = settings.history ?? defaultHistorySettings();
|
|
74
|
+
const limits = effectiveLimits(base, overrides);
|
|
75
|
+
const ranAt = new Date().toISOString();
|
|
76
|
+
|
|
77
|
+
const shouldPersistLimits =
|
|
78
|
+
normalizeOverride(overrides.retentionDays) !== undefined ||
|
|
79
|
+
normalizeOverride(overrides.maxRecords) !== undefined;
|
|
80
|
+
|
|
81
|
+
if (limits.retentionDays === 0 && limits.maxRecords === 0) {
|
|
82
|
+
const report: RetentionReport = {
|
|
83
|
+
deletedByAge: 0,
|
|
84
|
+
deletedByCount: 0,
|
|
85
|
+
deleted: 0,
|
|
86
|
+
kept: countHistory(),
|
|
87
|
+
cutoff: null,
|
|
88
|
+
retentionDays: 0,
|
|
89
|
+
maxRecords: 0,
|
|
90
|
+
vacuumed: false,
|
|
91
|
+
skipped: "Ретеншн выключен: history.retentionDays и history.maxRecords равны 0.",
|
|
92
|
+
ranAt,
|
|
93
|
+
};
|
|
94
|
+
if (shouldPersistLimits) {
|
|
95
|
+
await saveSettings({ history: { ...base, ...limits, lastCleanupAt: ranAt, lastCleanupDeleted: 0 } });
|
|
96
|
+
}
|
|
97
|
+
return report;
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
const pruned = pruneHistory({
|
|
101
|
+
retentionDays: limits.retentionDays,
|
|
102
|
+
maxRecords: limits.maxRecords,
|
|
103
|
+
});
|
|
104
|
+
const vacuumed = pruned.deleted > 0 ? vacuumHistory() : false;
|
|
105
|
+
|
|
106
|
+
await saveSettings({
|
|
107
|
+
history: {
|
|
108
|
+
...base,
|
|
109
|
+
...limits,
|
|
110
|
+
lastCleanupAt: ranAt,
|
|
111
|
+
lastCleanupDeleted: pruned.deleted,
|
|
112
|
+
},
|
|
113
|
+
});
|
|
114
|
+
|
|
115
|
+
return {
|
|
116
|
+
...pruned,
|
|
117
|
+
retentionDays: limits.retentionDays,
|
|
118
|
+
maxRecords: limits.maxRecords,
|
|
119
|
+
vacuumed,
|
|
120
|
+
skipped: null,
|
|
121
|
+
ranAt,
|
|
122
|
+
};
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
/**
|
|
126
|
+
* Автоочистка при старте плагина: не чаще одного раза в сутки.
|
|
127
|
+
* `force` игнорирует интервал (используется в тестах).
|
|
128
|
+
*/
|
|
129
|
+
export async function maybeRunHistoryRetention(
|
|
130
|
+
force = false
|
|
131
|
+
): Promise<RetentionReport | undefined> {
|
|
132
|
+
const settings = await loadSettings();
|
|
133
|
+
const history = settings.history ?? defaultHistorySettings();
|
|
134
|
+
if (!force && history.lastCleanupAt) {
|
|
135
|
+
const last = new Date(history.lastCleanupAt).getTime();
|
|
136
|
+
if (Number.isFinite(last) && Date.now() - last < CLEANUP_INTERVAL_MS) {
|
|
137
|
+
return undefined;
|
|
138
|
+
}
|
|
139
|
+
}
|
|
140
|
+
return await runHistoryRetention();
|
|
141
|
+
}
|
package/src/db/history-repo.ts
CHANGED
|
@@ -301,3 +301,96 @@ export function countHistory(): number {
|
|
|
301
301
|
const row = getDb().prepare("SELECT COUNT(*) AS count FROM history").get() as any;
|
|
302
302
|
return Number(row?.count) || 0;
|
|
303
303
|
}
|
|
304
|
+
|
|
305
|
+
/** Число активных (незавершённых) запусков: глубина очереди для /api/health. */
|
|
306
|
+
export function countRunningRecords(): number {
|
|
307
|
+
const row = getDb()
|
|
308
|
+
.prepare("SELECT COUNT(*) AS count FROM history WHERE finished_at IS NULL")
|
|
309
|
+
.get() as any;
|
|
310
|
+
return Number(row?.count) || 0;
|
|
311
|
+
}
|
|
312
|
+
|
|
313
|
+
/** Параметры очистки истории (Спринт 18). 0 — ограничение выключено. */
|
|
314
|
+
export interface PruneHistoryOptions {
|
|
315
|
+
/** Удалять завершённые записи старше N дней. */
|
|
316
|
+
retentionDays?: number;
|
|
317
|
+
/** Оставить не более N последних записей. */
|
|
318
|
+
maxRecords?: number;
|
|
319
|
+
/** Опорный момент времени (для тестов). */
|
|
320
|
+
now?: Date;
|
|
321
|
+
}
|
|
322
|
+
|
|
323
|
+
export interface PruneHistoryResult {
|
|
324
|
+
deletedByAge: number;
|
|
325
|
+
deletedByCount: number;
|
|
326
|
+
deleted: number;
|
|
327
|
+
kept: number;
|
|
328
|
+
/** Граница по возрасту (ISO) или null, если возраст не ограничивали. */
|
|
329
|
+
cutoff: string | null;
|
|
330
|
+
}
|
|
331
|
+
|
|
332
|
+
/**
|
|
333
|
+
* Чистит сырую историю: по возрасту и/или по количеству записей.
|
|
334
|
+
*
|
|
335
|
+
* Незавершённые запуски (`finished_at IS NULL`) не удаляются никогда — их
|
|
336
|
+
* обрабатывает crash recovery. Агрегаты в таблице metrics не трогаются:
|
|
337
|
+
* ретеншн чистит детали, а не статистику.
|
|
338
|
+
*/
|
|
339
|
+
export function pruneHistory(options: PruneHistoryOptions = {}): PruneHistoryResult {
|
|
340
|
+
const instance = getDb();
|
|
341
|
+
const now = options.now ?? new Date();
|
|
342
|
+
let deletedByAge = 0;
|
|
343
|
+
let deletedByCount = 0;
|
|
344
|
+
let cutoff: string | null = null;
|
|
345
|
+
|
|
346
|
+
const days = Number(options.retentionDays ?? 0);
|
|
347
|
+
if (Number.isFinite(days) && days > 0) {
|
|
348
|
+
cutoff = new Date(now.getTime() - days * 24 * 60 * 60 * 1000).toISOString();
|
|
349
|
+
const result = instance
|
|
350
|
+
.prepare(
|
|
351
|
+
`DELETE FROM history
|
|
352
|
+
WHERE finished_at IS NOT NULL AND finished_at < ?`
|
|
353
|
+
)
|
|
354
|
+
.run(cutoff);
|
|
355
|
+
deletedByAge = Number(result.changes) || 0;
|
|
356
|
+
}
|
|
357
|
+
|
|
358
|
+
const maxRecords = Number(options.maxRecords ?? 0);
|
|
359
|
+
if (Number.isFinite(maxRecords) && maxRecords > 0) {
|
|
360
|
+
const result = instance
|
|
361
|
+
.prepare(
|
|
362
|
+
`DELETE FROM history
|
|
363
|
+
WHERE finished_at IS NOT NULL
|
|
364
|
+
AND id NOT IN (
|
|
365
|
+
SELECT id FROM history
|
|
366
|
+
WHERE finished_at IS NOT NULL
|
|
367
|
+
ORDER BY started_at DESC, id DESC
|
|
368
|
+
LIMIT ?
|
|
369
|
+
)`
|
|
370
|
+
)
|
|
371
|
+
.run(Math.max(0, Math.floor(maxRecords)));
|
|
372
|
+
deletedByCount = Number(result.changes) || 0;
|
|
373
|
+
}
|
|
374
|
+
|
|
375
|
+
return {
|
|
376
|
+
deletedByAge,
|
|
377
|
+
deletedByCount,
|
|
378
|
+
deleted: deletedByAge + deletedByCount,
|
|
379
|
+
kept: countHistory(),
|
|
380
|
+
cutoff,
|
|
381
|
+
};
|
|
382
|
+
}
|
|
383
|
+
|
|
384
|
+
/**
|
|
385
|
+
* Освобождает место после массового удаления. `PRAGMA incremental_vacuum`
|
|
386
|
+
* работает только при auto_vacuum = INCREMENTAL; иначе это no-op, поэтому
|
|
387
|
+
* вызов безопасен и не требует проверки режима.
|
|
388
|
+
*/
|
|
389
|
+
export function vacuumHistory(): boolean {
|
|
390
|
+
try {
|
|
391
|
+
getDb().exec("PRAGMA incremental_vacuum");
|
|
392
|
+
return true;
|
|
393
|
+
} catch {
|
|
394
|
+
return false;
|
|
395
|
+
}
|
|
396
|
+
}
|