opencode-windows-scheduler 1.3.0 → 1.5.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 +47 -1
- package/README.md +11 -5
- package/ROADMAP-STRATEGY.md +45 -26
- package/ROADMAP.md +279 -35
- package/dist/core/audit.d.ts +68 -0
- package/dist/core/audit.d.ts.map +1 -0
- package/dist/core/audit.js +206 -0
- package/dist/core/dry-run.d.ts +31 -0
- package/dist/core/dry-run.d.ts.map +1 -1
- package/dist/core/dry-run.js +129 -1
- package/dist/core/file-watcher.d.ts.map +1 -1
- package/dist/core/file-watcher.js +53 -10
- package/dist/core/git-trigger.d.ts +80 -0
- package/dist/core/git-trigger.d.ts.map +1 -0
- package/dist/core/git-trigger.js +288 -0
- package/dist/core/glob.d.ts +38 -0
- package/dist/core/glob.d.ts.map +1 -0
- package/dist/core/glob.js +233 -0
- package/dist/core/ps-wrapper.d.ts.map +1 -1
- package/dist/core/ps-wrapper.js +7 -0
- package/dist/core/schedule-gate.js +55 -30
- package/dist/core/schedule-v2.d.ts +29 -1
- package/dist/core/schedule-v2.d.ts.map +1 -1
- package/dist/core/schedule-v2.js +81 -3
- package/dist/core/scheduler/types.d.ts +1 -1
- package/dist/core/scheduler/types.d.ts.map +1 -1
- package/dist/core/secrets.d.ts +57 -0
- package/dist/core/secrets.d.ts.map +1 -0
- package/dist/core/secrets.js +331 -0
- package/dist/core/structured-log.d.ts.map +1 -1
- package/dist/core/structured-log.js +9 -0
- package/dist/core/wrappers/bash.d.ts.map +1 -1
- package/dist/core/wrappers/bash.js +4 -0
- package/dist/db/git-state-repo.d.ts +16 -0
- package/dist/db/git-state-repo.d.ts.map +1 -0
- package/dist/db/git-state-repo.js +38 -0
- package/dist/db/schema.d.ts +1 -1
- package/dist/db/schema.d.ts.map +1 -1
- package/dist/db/schema.js +23 -0
- package/dist/index.d.ts +68 -4
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +589 -45
- package/dist/rpc.d.ts +623 -0
- package/dist/rpc.d.ts.map +1 -1
- package/dist/rpc.js +219 -0
- package/dist/server.d.ts.map +1 -1
- package/dist/server.js +67 -0
- package/dist/settings.d.ts +16 -0
- package/dist/settings.d.ts.map +1 -1
- package/dist/settings.js +29 -0
- package/dist/task-transfer.d.ts +30 -3
- package/dist/task-transfer.d.ts.map +1 -1
- package/dist/task-transfer.js +83 -6
- package/dist/templates.d.ts +1 -1
- package/dist/templates.d.ts.map +1 -1
- package/dist/workspaces.d.ts +8 -2
- package/dist/workspaces.d.ts.map +1 -1
- package/dist/workspaces.js +21 -4
- package/docs/ARCHITECTURE.md +14 -5
- package/docs/FEATURES.md +80 -1
- package/docs/README.ru.md +15 -5
- package/gui-experimental.cjs +9 -4
- package/package.json +8 -3
- package/src/core/audit.ts +291 -0
- package/src/core/dry-run.ts +188 -1
- package/src/core/file-watcher.ts +65 -10
- package/src/core/git-trigger.ts +367 -0
- package/src/core/glob.ts +226 -0
- package/src/core/ps-wrapper.ts +7 -0
- package/src/core/schedule-gate.ts +67 -33
- package/src/core/schedule-v2.ts +108 -3
- package/src/core/scheduler/types.ts +1 -1
- package/src/core/secrets.ts +385 -0
- package/src/core/structured-log.ts +9 -0
- package/src/core/wrappers/bash.ts +4 -0
- package/src/db/git-state-repo.ts +62 -0
- package/src/db/schema.ts +23 -0
- package/src/gui.tsx +548 -4
- package/src/index.ts +790 -47
- package/src/rpc.ts +230 -0
- package/src/server.ts +67 -0
- package/src/settings.ts +51 -0
- package/src/task-transfer.ts +124 -5
- package/src/templates.ts +1 -1
- package/src/workspaces.ts +22 -4
|
@@ -29,12 +29,12 @@
|
|
|
29
29
|
*/
|
|
30
30
|
import fs from "node:fs";
|
|
31
31
|
import {
|
|
32
|
+
activeWindowState,
|
|
32
33
|
cronMatches,
|
|
33
34
|
isValidIanaTimeZone,
|
|
34
|
-
|
|
35
|
+
normalizeActiveDays,
|
|
35
36
|
parseCron,
|
|
36
37
|
validateLaunchWindow,
|
|
37
|
-
windowDelayMs,
|
|
38
38
|
} from "./schedule-v2.js";
|
|
39
39
|
|
|
40
40
|
const STALE_DEFER_MS = 25 * 60 * 60 * 1000;
|
|
@@ -42,6 +42,9 @@ const STALE_DEFER_MS = 25 * 60 * 60 * 1000;
|
|
|
42
42
|
/** Сколько живёт маркер ручного запуска. */
|
|
43
43
|
const FORCE_TTL_MS = 2 * 60 * 1000;
|
|
44
44
|
|
|
45
|
+
/** Дольше 12 часов перенос не ждём — тик просто пропускается. */
|
|
46
|
+
const MAX_POSTPONE_MS = 12 * 60 * 60 * 1000;
|
|
47
|
+
|
|
45
48
|
function argValue(args: string[], name: string): string | undefined {
|
|
46
49
|
const idx = args.indexOf(name);
|
|
47
50
|
if (idx === -1 || idx + 1 >= args.length) return undefined;
|
|
@@ -113,10 +116,23 @@ async function main(): Promise<number> {
|
|
|
113
116
|
const tz = argValue(args, "--tz");
|
|
114
117
|
const notBefore = argValue(args, "--not-before");
|
|
115
118
|
const notAfter = argValue(args, "--not-after");
|
|
119
|
+
const daysArg = argValue(args, "--days");
|
|
120
|
+
const policyArg = argValue(args, "--window-policy");
|
|
116
121
|
const deferFile = argValue(args, "--defer-file");
|
|
117
122
|
const forceFile = argValue(args, "--force-file");
|
|
118
123
|
const nowArg = argValue(args, "--now");
|
|
119
124
|
|
|
125
|
+
const days = daysArg
|
|
126
|
+
? normalizeActiveDays(
|
|
127
|
+
daysArg
|
|
128
|
+
.split(",")
|
|
129
|
+
.map((value) => Number(value.trim()))
|
|
130
|
+
.filter((value) => Number.isFinite(value))
|
|
131
|
+
)
|
|
132
|
+
: undefined;
|
|
133
|
+
const policy: "skip" | "postpone" | "run" =
|
|
134
|
+
policyArg === "skip" || policyArg === "run" ? policyArg : "postpone";
|
|
135
|
+
|
|
120
136
|
const now = nowArg ? new Date(nowArg) : new Date();
|
|
121
137
|
if (Number.isNaN(now.getTime())) {
|
|
122
138
|
console.error(`[schedule-gate] Некорректное значение --now: ${nowArg}`);
|
|
@@ -139,7 +155,6 @@ async function main(): Promise<number> {
|
|
|
139
155
|
if (windowError) {
|
|
140
156
|
console.error(`[schedule-gate] Окно запуска игнорируется: ${windowError}`);
|
|
141
157
|
}
|
|
142
|
-
const windowOk = !windowError && !!notBefore && !!notAfter;
|
|
143
158
|
|
|
144
159
|
let spec = null;
|
|
145
160
|
if (cronExpr) {
|
|
@@ -159,43 +174,62 @@ async function main(): Promise<number> {
|
|
|
159
174
|
return 3;
|
|
160
175
|
}
|
|
161
176
|
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
177
|
+
// Дни недели и окно запуска (Спринт 27). Политика вне окна:
|
|
178
|
+
// postpone (по умолчанию) — ждём открытия окна;
|
|
179
|
+
// skip — тихо пропускаем тик;
|
|
180
|
+
// run — выполняем, несмотря на окно.
|
|
181
|
+
const windowOptions = { notBefore, notAfter, days, timeZone: zone };
|
|
182
|
+
if (policy !== "run") {
|
|
183
|
+
const state = activeWindowState(now, windowOptions);
|
|
184
|
+
if (!state.active) {
|
|
185
|
+
if (policy === "skip") {
|
|
186
|
+
console.error(`[schedule-gate] Пропуск: ${state.reason ?? "вне окна"}.`);
|
|
171
187
|
return 3;
|
|
172
188
|
}
|
|
173
|
-
|
|
174
|
-
|
|
189
|
+
|
|
190
|
+
const wait = state.nextOpenAt
|
|
191
|
+
? Math.max(0, state.nextOpenAt.getTime() - now.getTime())
|
|
192
|
+
: 0;
|
|
193
|
+
if (wait <= 0) return 0;
|
|
194
|
+
if (wait > MAX_POSTPONE_MS) {
|
|
195
|
+
console.error(
|
|
196
|
+
`[schedule-gate] ${state.reason ?? "вне окна"} — до открытия больше 12 часов, тик пропущен.`
|
|
197
|
+
);
|
|
175
198
|
return 3;
|
|
176
199
|
}
|
|
177
|
-
}
|
|
178
200
|
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
if (isInWindow(woke, notBefore, notAfter, zone)) break;
|
|
192
|
-
}
|
|
201
|
+
// ПЕРЕНОС: ждём открытия окна. Откладываем один запуск, остальные тики
|
|
202
|
+
// отсекаются по defer-файлу.
|
|
203
|
+
if (deferFile) {
|
|
204
|
+
if (deferFileBusy(deferFile, now.getTime())) {
|
|
205
|
+
console.error("[schedule-gate] Отложенный запуск уже ожидает открытия окна.");
|
|
206
|
+
return 3;
|
|
207
|
+
}
|
|
208
|
+
if (!acquireDefer(deferFile, now.getTime())) {
|
|
209
|
+
console.error("[schedule-gate] Не удалось захватить defer-файл — пропускаем.");
|
|
210
|
+
return 3;
|
|
211
|
+
}
|
|
212
|
+
}
|
|
193
213
|
|
|
194
|
-
|
|
214
|
+
console.error(
|
|
215
|
+
`[schedule-gate] ${state.reason ?? "Вне окна"} — запуск перенесён на ~${Math.round(
|
|
216
|
+
wait / 60000
|
|
217
|
+
)} мин.`
|
|
218
|
+
);
|
|
219
|
+
let remaining = wait;
|
|
220
|
+
while (remaining > 0) {
|
|
221
|
+
const chunk = Math.min(remaining, 60_000);
|
|
222
|
+
await sleepMs(chunk);
|
|
223
|
+
remaining -= chunk;
|
|
224
|
+
}
|
|
195
225
|
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
226
|
+
const woke = new Date();
|
|
227
|
+
if (deferFile) releaseDefer(deferFile);
|
|
228
|
+
|
|
229
|
+
if (!activeWindowState(woke, windowOptions).active) {
|
|
230
|
+
console.error("[schedule-gate] Окно не открылось за отведённое время — не запускаем.");
|
|
231
|
+
return 3;
|
|
232
|
+
}
|
|
199
233
|
}
|
|
200
234
|
}
|
|
201
235
|
|
package/src/core/schedule-v2.ts
CHANGED
|
@@ -466,6 +466,96 @@ export function windowDelayMs(now: Date, notBefore?: string | null, notAfter?: s
|
|
|
466
466
|
return Math.max(0, deltaSec * 1000 - ms);
|
|
467
467
|
}
|
|
468
468
|
|
|
469
|
+
// ---------------------------------------------------------------------------
|
|
470
|
+
// Дни недели и политика вне окна (Спринт 27).
|
|
471
|
+
|
|
472
|
+
/** 0=Вс..6=Сб. Пустой/полный список трактуется как «все дни» (undefined). */
|
|
473
|
+
export function normalizeActiveDays(days?: number[] | null): number[] | undefined {
|
|
474
|
+
if (!Array.isArray(days)) return undefined;
|
|
475
|
+
const unique = [
|
|
476
|
+
...new Set(
|
|
477
|
+
days
|
|
478
|
+
.map((value) => Math.floor(Number(value)))
|
|
479
|
+
.filter((value) => Number.isInteger(value) && value >= 0 && value <= 6)
|
|
480
|
+
),
|
|
481
|
+
].sort((a, b) => a - b);
|
|
482
|
+
if (unique.length === 0 || unique.length === 7) return undefined;
|
|
483
|
+
return unique;
|
|
484
|
+
}
|
|
485
|
+
|
|
486
|
+
/** Разрешён ли день недели (в поясе задачи). */
|
|
487
|
+
export function isActiveDay(now: Date, days?: number[] | null, timeZone?: string): boolean {
|
|
488
|
+
const normalized = normalizeActiveDays(days);
|
|
489
|
+
if (!normalized) return true;
|
|
490
|
+
return normalized.includes(zonedParts(now, timeZone).weekday);
|
|
491
|
+
}
|
|
492
|
+
|
|
493
|
+
export interface ActiveWindowOptions {
|
|
494
|
+
notBefore?: string | null;
|
|
495
|
+
notAfter?: string | null;
|
|
496
|
+
days?: number[] | null;
|
|
497
|
+
timeZone?: string;
|
|
498
|
+
}
|
|
499
|
+
|
|
500
|
+
export interface ActiveWindowState {
|
|
501
|
+
/** Можно запускать сейчас. */
|
|
502
|
+
active: boolean;
|
|
503
|
+
/** Почему нельзя (человекочитаемо, для dry-run и логов). */
|
|
504
|
+
reason?: string;
|
|
505
|
+
/** Ближайшее открытие окна; null — не требуется или не найдено. */
|
|
506
|
+
nextOpenAt: Date | null;
|
|
507
|
+
}
|
|
508
|
+
|
|
509
|
+
const WINDOW_SCAN_MINUTES = 8 * 24 * 60;
|
|
510
|
+
|
|
511
|
+
/** Ближайшая минута, когда и день, и окно разрешают запуск. */
|
|
512
|
+
export function nextWindowOpenAt(now: Date, options: ActiveWindowOptions): Date | null {
|
|
513
|
+
const { notBefore, notAfter, timeZone } = options;
|
|
514
|
+
const normalizedDays = normalizeActiveDays(options.days);
|
|
515
|
+
const hasWindow = Boolean((notBefore || "").trim() || (notAfter || "").trim());
|
|
516
|
+
if (!hasWindow && !normalizedDays) return null;
|
|
517
|
+
const invalidWindow = validateLaunchWindow(notBefore, notAfter) !== null;
|
|
518
|
+
for (let i = 1; i <= WINDOW_SCAN_MINUTES; i++) {
|
|
519
|
+
const candidate = new Date(now.getTime() + i * 60_000);
|
|
520
|
+
const dayOk =
|
|
521
|
+
!normalizedDays || normalizedDays.includes(zonedParts(candidate, timeZone).weekday);
|
|
522
|
+
const windowOk = invalidWindow || isInWindow(candidate, notBefore, notAfter, timeZone);
|
|
523
|
+
if (dayOk && windowOk) return candidate;
|
|
524
|
+
}
|
|
525
|
+
return null;
|
|
526
|
+
}
|
|
527
|
+
|
|
528
|
+
/** Состояние окна с учётом дней недели. */
|
|
529
|
+
export function activeWindowState(now: Date, options: ActiveWindowOptions = {}): ActiveWindowState {
|
|
530
|
+
const normalizedDays = normalizeActiveDays(options.days);
|
|
531
|
+
const dayOk =
|
|
532
|
+
!normalizedDays ||
|
|
533
|
+
normalizedDays.includes(zonedParts(now, options.timeZone).weekday);
|
|
534
|
+
const windowOk = isInWindow(now, options.notBefore, options.notAfter, options.timeZone);
|
|
535
|
+
if (dayOk && windowOk) return { active: true, nextOpenAt: null };
|
|
536
|
+
|
|
537
|
+
const reasons: string[] = [];
|
|
538
|
+
if (!dayOk) {
|
|
539
|
+
const names = ["Вс", "Пн", "Вт", "Ср", "Чт", "Пт", "Сб"];
|
|
540
|
+
reasons.push(`день недели не разрешён (${(normalizedDays ?? []).map((d) => names[d]).join(", ")})`);
|
|
541
|
+
}
|
|
542
|
+
if (!windowOk) {
|
|
543
|
+
reasons.push(`время вне окна ${options.notBefore}–${options.notAfter}`);
|
|
544
|
+
}
|
|
545
|
+
return {
|
|
546
|
+
active: false,
|
|
547
|
+
reason: reasons.join("; "),
|
|
548
|
+
nextOpenAt: nextWindowOpenAt(now, options),
|
|
549
|
+
};
|
|
550
|
+
}
|
|
551
|
+
|
|
552
|
+
/** Сколько мс до следующего разрешённого окна (0 — можно запускать). */
|
|
553
|
+
export function nextWindowOpenDelayMs(now: Date, options: ActiveWindowOptions = {}): number {
|
|
554
|
+
const state = activeWindowState(now, options);
|
|
555
|
+
if (state.active) return 0;
|
|
556
|
+
return state.nextOpenAt ? Math.max(0, state.nextOpenAt.getTime() - now.getTime()) : 0;
|
|
557
|
+
}
|
|
558
|
+
|
|
469
559
|
// ---------------------------------------------------------------------------
|
|
470
560
|
// Проверка совместимости с schtasks (родной режим).
|
|
471
561
|
|
|
@@ -502,6 +592,10 @@ export interface ScheduleGateSpec {
|
|
|
502
592
|
tz?: string;
|
|
503
593
|
notBefore?: string;
|
|
504
594
|
notAfter?: string;
|
|
595
|
+
/** Разрешённые дни недели (0=Вс..6=Сб); пусто — все дни. */
|
|
596
|
+
days?: number[];
|
|
597
|
+
/** Поведение вне окна: skip — пропустить, run — выполнить всё равно. */
|
|
598
|
+
windowPolicy?: "skip" | "run";
|
|
505
599
|
}
|
|
506
600
|
|
|
507
601
|
/**
|
|
@@ -523,11 +617,22 @@ export function buildScheduleGate(
|
|
|
523
617
|
expr: string,
|
|
524
618
|
timezone?: string | null,
|
|
525
619
|
notBefore?: string,
|
|
526
|
-
notAfter?: string
|
|
620
|
+
notAfter?: string,
|
|
621
|
+
days?: number[] | null,
|
|
622
|
+
windowPolicy?: string | null
|
|
527
623
|
): ScheduleGateSpec | undefined {
|
|
528
624
|
const tz = (timezone || "").trim() || undefined;
|
|
529
625
|
const poll = needsPollMode(expr, tz);
|
|
530
|
-
|
|
626
|
+
const normalizedDays = normalizeActiveDays(days);
|
|
627
|
+
const policy = windowPolicy === "skip" || windowPolicy === "run" ? windowPolicy : undefined;
|
|
628
|
+
if (!poll && !(notBefore && notAfter) && !normalizedDays) return undefined;
|
|
531
629
|
// cron проверяем только в poll-режиме (см. комментарий у ScheduleGateSpec).
|
|
532
|
-
return {
|
|
630
|
+
return {
|
|
631
|
+
...(poll ? { cron: expr } : {}),
|
|
632
|
+
tz,
|
|
633
|
+
notBefore,
|
|
634
|
+
notAfter,
|
|
635
|
+
...(normalizedDays ? { days: normalizedDays } : {}),
|
|
636
|
+
...(policy ? { windowPolicy: policy } : {}),
|
|
637
|
+
};
|
|
533
638
|
}
|
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
import type { ScheduledTaskInfo } from "../../types.js";
|
|
2
2
|
|
|
3
3
|
/** Чем запускается задача. */
|
|
4
|
-
export type TriggerType = "cron" | "file" | "mcp-event" | "once";
|
|
4
|
+
export type TriggerType = "cron" | "file" | "git" | "mcp-event" | "once";
|
|
5
5
|
|
|
6
6
|
/**
|
|
7
7
|
* Параметры создания задачи. Бэкенд сам решает, как преобразовать cron
|
|
@@ -0,0 +1,385 @@
|
|
|
1
|
+
import crypto from "node:crypto";
|
|
2
|
+
import fs from "node:fs";
|
|
3
|
+
import path from "node:path";
|
|
4
|
+
import { PLUGIN_DIR } from "../types.js";
|
|
5
|
+
|
|
6
|
+
/**
|
|
7
|
+
* Зашифрованное хранилище секретов (Спринт 26).
|
|
8
|
+
*
|
|
9
|
+
* Зависимостей нет: ключ 32 байта лежит в `secrets.key` (права 0600), сами
|
|
10
|
+
* значения — в `secrets.json`, зашифрованные AES-256-GCM. Имя секрета
|
|
11
|
+
* используется как AAD, поэтому перестановка записей между именами ломает
|
|
12
|
+
* расшифровку. В открытом виде секреты не попадают ни в settings.json, ни в
|
|
13
|
+
* tasks.json, ни в историю, ни в логи — для этого есть resolveSecretRefs()
|
|
14
|
+
* и redactSecretsInText().
|
|
15
|
+
*
|
|
16
|
+
* Ссылка на секрет в env выглядит как `${secret:NAME}`. Ссылка может быть
|
|
17
|
+
* частью значения: `Authorization=Bearer ${secret:GITHUB_TOKEN}`.
|
|
18
|
+
*/
|
|
19
|
+
|
|
20
|
+
export const SECRETS_FILE = path.join(PLUGIN_DIR, "secrets.json");
|
|
21
|
+
export const SECRETS_KEY_FILE = path.join(PLUGIN_DIR, "secrets.key");
|
|
22
|
+
export const SECRET_REF_RE = /\$\{secret:([A-Za-z0-9_.-]{1,64})\}/g;
|
|
23
|
+
const SECRET_NAME_RE = /^[A-Za-z0-9_.-]{1,64}$/;
|
|
24
|
+
const KEY_BYTES = 32;
|
|
25
|
+
|
|
26
|
+
interface StoredSecret {
|
|
27
|
+
/** IV в base64 (12 байт). */
|
|
28
|
+
iv: string;
|
|
29
|
+
/** Auth tag в base64 (16 байт). */
|
|
30
|
+
tag: string;
|
|
31
|
+
/** Шифротекст в base64. */
|
|
32
|
+
data: string;
|
|
33
|
+
updatedAt: string;
|
|
34
|
+
}
|
|
35
|
+
|
|
36
|
+
interface SecretsFile {
|
|
37
|
+
version: 1;
|
|
38
|
+
secrets: Record<string, StoredSecret>;
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
export interface SecretListItem {
|
|
42
|
+
name: string;
|
|
43
|
+
/** Маска вида `••••ABCD` — само значение никогда не возвращается. */
|
|
44
|
+
preview: string;
|
|
45
|
+
updatedAt: string;
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
interface CacheEntry {
|
|
49
|
+
stamp: string;
|
|
50
|
+
file: SecretsFile;
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
let cache: CacheEntry | null = null;
|
|
54
|
+
let keyCache: { stamp: string; key: Buffer } | null = null;
|
|
55
|
+
|
|
56
|
+
function warn(message: string, err: unknown): void {
|
|
57
|
+
try {
|
|
58
|
+
console.warn(
|
|
59
|
+
`[secrets] ${message}: ${err instanceof Error ? err.message : String(err)}`
|
|
60
|
+
);
|
|
61
|
+
} catch {
|
|
62
|
+
// console может быть недоступен — молча игнорируем.
|
|
63
|
+
}
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
/** Проверяет имя секрета; возвращает trimmed-значение. */
|
|
67
|
+
export function validateSecretName(name: string): string {
|
|
68
|
+
const value = String(name ?? "").trim();
|
|
69
|
+
if (!SECRET_NAME_RE.test(value)) {
|
|
70
|
+
throw new Error(
|
|
71
|
+
"Имя секрета: латиница, цифры, '_', '.', '-', от 1 до 64 символов."
|
|
72
|
+
);
|
|
73
|
+
}
|
|
74
|
+
return value;
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
/** true, если значение содержит хотя бы одну ссылку `${secret:...}`. */
|
|
78
|
+
export function hasSecretRef(value: unknown): boolean {
|
|
79
|
+
if (typeof value !== "string") return false;
|
|
80
|
+
SECRET_REF_RE.lastIndex = 0;
|
|
81
|
+
return SECRET_REF_RE.test(value);
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
function ensureDir(): void {
|
|
85
|
+
fs.mkdirSync(PLUGIN_DIR, { recursive: true });
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
function chmodPrivate(file: string): void {
|
|
89
|
+
if (process.platform === "win32") return;
|
|
90
|
+
try {
|
|
91
|
+
fs.chmodSync(file, 0o600);
|
|
92
|
+
} catch {
|
|
93
|
+
// ACL на некоторых ФС не поддерживают chmod — не критично.
|
|
94
|
+
}
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
/** Читает или создаёт ключ шифрования. */
|
|
98
|
+
function loadKey(): Buffer {
|
|
99
|
+
ensureDir();
|
|
100
|
+
try {
|
|
101
|
+
const stat = fs.statSync(SECRETS_KEY_FILE);
|
|
102
|
+
const stamp = `${stat.mtimeMs}:${stat.size}`;
|
|
103
|
+
if (keyCache && keyCache.stamp === stamp) return keyCache.key;
|
|
104
|
+
const raw = fs.readFileSync(SECRETS_KEY_FILE);
|
|
105
|
+
if (raw.length !== KEY_BYTES) {
|
|
106
|
+
throw new Error("повреждён файл ключа секретов");
|
|
107
|
+
}
|
|
108
|
+
keyCache = { stamp, key: raw };
|
|
109
|
+
return raw;
|
|
110
|
+
} catch (err: any) {
|
|
111
|
+
if (err?.code !== "ENOENT") throw err;
|
|
112
|
+
const key = crypto.randomBytes(KEY_BYTES);
|
|
113
|
+
fs.writeFileSync(SECRETS_KEY_FILE, key, { mode: 0o600 });
|
|
114
|
+
chmodPrivate(SECRETS_KEY_FILE);
|
|
115
|
+
keyCache = { stamp: `${fs.statSync(SECRETS_KEY_FILE).mtimeMs}:${KEY_BYTES}`, key };
|
|
116
|
+
return key;
|
|
117
|
+
}
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
function emptyFile(): SecretsFile {
|
|
121
|
+
return { version: 1, secrets: {} };
|
|
122
|
+
}
|
|
123
|
+
|
|
124
|
+
/** Читает secrets.json с кэшем по mtime/size. Битый файл — пустое хранилище. */
|
|
125
|
+
function readFileSafe(): SecretsFile {
|
|
126
|
+
try {
|
|
127
|
+
const stat = fs.statSync(SECRETS_FILE);
|
|
128
|
+
const stamp = `${stat.mtimeMs}:${stat.size}`;
|
|
129
|
+
if (cache && cache.stamp === stamp) return cache.file;
|
|
130
|
+
const parsed = JSON.parse(fs.readFileSync(SECRETS_FILE, "utf8"));
|
|
131
|
+
if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
|
|
132
|
+
throw new Error("некорректный формат secrets.json");
|
|
133
|
+
}
|
|
134
|
+
const rawSecrets = (parsed as any).secrets;
|
|
135
|
+
const secrets: Record<string, StoredSecret> = {};
|
|
136
|
+
if (rawSecrets && typeof rawSecrets === "object" && !Array.isArray(rawSecrets)) {
|
|
137
|
+
for (const [name, entry] of Object.entries(rawSecrets)) {
|
|
138
|
+
const record = entry as Partial<StoredSecret>;
|
|
139
|
+
if (
|
|
140
|
+
SECRET_NAME_RE.test(name) &&
|
|
141
|
+
typeof record?.iv === "string" &&
|
|
142
|
+
typeof record?.tag === "string" &&
|
|
143
|
+
typeof record?.data === "string"
|
|
144
|
+
) {
|
|
145
|
+
secrets[name] = {
|
|
146
|
+
iv: record.iv,
|
|
147
|
+
tag: record.tag,
|
|
148
|
+
data: record.data,
|
|
149
|
+
updatedAt:
|
|
150
|
+
typeof record.updatedAt === "string"
|
|
151
|
+
? record.updatedAt
|
|
152
|
+
: new Date(0).toISOString(),
|
|
153
|
+
};
|
|
154
|
+
}
|
|
155
|
+
}
|
|
156
|
+
}
|
|
157
|
+
const file: SecretsFile = { version: 1, secrets };
|
|
158
|
+
cache = { stamp, file };
|
|
159
|
+
return file;
|
|
160
|
+
} catch (err: any) {
|
|
161
|
+
if (err?.code !== "ENOENT") warn("не удалось прочитать secrets.json", err);
|
|
162
|
+
return emptyFile();
|
|
163
|
+
}
|
|
164
|
+
}
|
|
165
|
+
|
|
166
|
+
/** Атомарная запись: temp + rename, права 0600. */
|
|
167
|
+
function writeFileSafe(file: SecretsFile): void {
|
|
168
|
+
ensureDir();
|
|
169
|
+
const tmp = `${SECRETS_FILE}.tmp`;
|
|
170
|
+
fs.writeFileSync(tmp, JSON.stringify(file, null, 2), { encoding: "utf8", mode: 0o600 });
|
|
171
|
+
try {
|
|
172
|
+
fs.rmSync(SECRETS_FILE, { force: true });
|
|
173
|
+
} catch {
|
|
174
|
+
// файла нет — не ошибка
|
|
175
|
+
}
|
|
176
|
+
fs.renameSync(tmp, SECRETS_FILE);
|
|
177
|
+
chmodPrivate(SECRETS_FILE);
|
|
178
|
+
try {
|
|
179
|
+
const stat = fs.statSync(SECRETS_FILE);
|
|
180
|
+
cache = { stamp: `${stat.mtimeMs}:${stat.size}`, file };
|
|
181
|
+
} catch {
|
|
182
|
+
cache = null;
|
|
183
|
+
}
|
|
184
|
+
}
|
|
185
|
+
|
|
186
|
+
function encryptValue(name: string, value: string, key: Buffer): StoredSecret {
|
|
187
|
+
const iv = crypto.randomBytes(12);
|
|
188
|
+
const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
|
|
189
|
+
cipher.setAAD(Buffer.from(name, "utf8"));
|
|
190
|
+
const data = Buffer.concat([cipher.update(value, "utf8"), cipher.final()]);
|
|
191
|
+
return {
|
|
192
|
+
iv: iv.toString("base64"),
|
|
193
|
+
tag: cipher.getAuthTag().toString("base64"),
|
|
194
|
+
data: data.toString("base64"),
|
|
195
|
+
updatedAt: new Date().toISOString(),
|
|
196
|
+
};
|
|
197
|
+
}
|
|
198
|
+
|
|
199
|
+
function decryptValue(name: string, entry: StoredSecret, key: Buffer): string {
|
|
200
|
+
const decipher = crypto.createDecipheriv(
|
|
201
|
+
"aes-256-gcm",
|
|
202
|
+
key,
|
|
203
|
+
Buffer.from(entry.iv, "base64")
|
|
204
|
+
);
|
|
205
|
+
decipher.setAAD(Buffer.from(name, "utf8"));
|
|
206
|
+
decipher.setAuthTag(Buffer.from(entry.tag, "base64"));
|
|
207
|
+
return Buffer.concat([
|
|
208
|
+
decipher.update(Buffer.from(entry.data, "base64")),
|
|
209
|
+
decipher.final(),
|
|
210
|
+
]).toString("utf8");
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
/** Сохраняет (или перезаписывает) секрет. Значение не логируется. */
|
|
214
|
+
export function setSecret(name: string, value: string): SecretListItem {
|
|
215
|
+
const secretName = validateSecretName(name);
|
|
216
|
+
const text = String(value ?? "");
|
|
217
|
+
const key = loadKey();
|
|
218
|
+
const file = readFileSafe();
|
|
219
|
+
file.secrets[secretName] = encryptValue(secretName, text, key);
|
|
220
|
+
writeFileSafe(file);
|
|
221
|
+
return {
|
|
222
|
+
name: secretName,
|
|
223
|
+
preview: previewOf(text),
|
|
224
|
+
updatedAt: file.secrets[secretName].updatedAt,
|
|
225
|
+
};
|
|
226
|
+
}
|
|
227
|
+
|
|
228
|
+
/** Читает секрет; undefined, если его нет или он не расшифровывается. */
|
|
229
|
+
export function getSecret(name: string): string | undefined {
|
|
230
|
+
try {
|
|
231
|
+
const secretName = validateSecretName(name);
|
|
232
|
+
const file = readFileSafe();
|
|
233
|
+
const entry = file.secrets[secretName];
|
|
234
|
+
if (!entry) return undefined;
|
|
235
|
+
return decryptValue(secretName, entry, loadKey());
|
|
236
|
+
} catch (err) {
|
|
237
|
+
warn("не удалось расшифровать секрет", err);
|
|
238
|
+
return undefined;
|
|
239
|
+
}
|
|
240
|
+
}
|
|
241
|
+
|
|
242
|
+
/** true, если секрет существует и расшифровывается. */
|
|
243
|
+
export function hasSecret(name: string): boolean {
|
|
244
|
+
return getSecret(name) !== undefined;
|
|
245
|
+
}
|
|
246
|
+
|
|
247
|
+
/** Удаляет секрет; true — запись была. */
|
|
248
|
+
export function deleteSecret(name: string): boolean {
|
|
249
|
+
const secretName = validateSecretName(name);
|
|
250
|
+
const file = readFileSafe();
|
|
251
|
+
if (!(secretName in file.secrets)) return false;
|
|
252
|
+
delete file.secrets[secretName];
|
|
253
|
+
writeFileSafe(file);
|
|
254
|
+
return true;
|
|
255
|
+
}
|
|
256
|
+
|
|
257
|
+
function previewOf(value: string): string {
|
|
258
|
+
const text = String(value ?? "");
|
|
259
|
+
if (!text) return "••••";
|
|
260
|
+
const tail = text.length >= 4 ? text.slice(-4) : "";
|
|
261
|
+
return tail ? `••••${tail}` : "••••";
|
|
262
|
+
}
|
|
263
|
+
|
|
264
|
+
/** Список секретов без значений (только имена, маски и время обновления). */
|
|
265
|
+
export function listSecrets(): SecretListItem[] {
|
|
266
|
+
const file = readFileSafe();
|
|
267
|
+
return Object.keys(file.secrets)
|
|
268
|
+
.sort((a, b) => a.localeCompare(b))
|
|
269
|
+
.map((name) => {
|
|
270
|
+
let preview = "••••";
|
|
271
|
+
try {
|
|
272
|
+
const value = decryptValue(name, file.secrets[name], loadKey());
|
|
273
|
+
preview = previewOf(value);
|
|
274
|
+
} catch {
|
|
275
|
+
preview = "••••";
|
|
276
|
+
}
|
|
277
|
+
return { name, preview, updatedAt: file.secrets[name].updatedAt };
|
|
278
|
+
});
|
|
279
|
+
}
|
|
280
|
+
|
|
281
|
+
/** Подставляет все ссылки `${secret:NAME}` в строку. */
|
|
282
|
+
export function expandSecretRefs(value: string): {
|
|
283
|
+
value: string;
|
|
284
|
+
missing: string[];
|
|
285
|
+
} {
|
|
286
|
+
const missing = new Set<string>();
|
|
287
|
+
const result = String(value ?? "").replace(SECRET_REF_RE, (_match, name: string) => {
|
|
288
|
+
const secret = getSecret(name);
|
|
289
|
+
if (secret === undefined) {
|
|
290
|
+
missing.add(name);
|
|
291
|
+
return "";
|
|
292
|
+
}
|
|
293
|
+
return secret;
|
|
294
|
+
});
|
|
295
|
+
return { value: result, missing: [...missing] };
|
|
296
|
+
}
|
|
297
|
+
|
|
298
|
+
/**
|
|
299
|
+
* Разворачивает ссылки во всех значениях env. Отсутствующие секреты дают
|
|
300
|
+
* пустую строку и попадают в `missing` (только имена — без значений).
|
|
301
|
+
*/
|
|
302
|
+
export function resolveSecretRefs(env: Record<string, string>): {
|
|
303
|
+
env: Record<string, string>;
|
|
304
|
+
missing: string[];
|
|
305
|
+
} {
|
|
306
|
+
const resolved: Record<string, string> = {};
|
|
307
|
+
const missing = new Set<string>();
|
|
308
|
+
for (const [key, value] of Object.entries(env ?? {})) {
|
|
309
|
+
const result = expandSecretRefs(String(value ?? ""));
|
|
310
|
+
resolved[key] = result.value;
|
|
311
|
+
for (const name of result.missing) missing.add(name);
|
|
312
|
+
}
|
|
313
|
+
return { env: resolved, missing: [...missing] };
|
|
314
|
+
}
|
|
315
|
+
|
|
316
|
+
/** Все расшифрованные значения (для редактирования текста). Кэш на 5 секунд. */
|
|
317
|
+
let valuesCache: { at: number; values: string[] } | null = null;
|
|
318
|
+
|
|
319
|
+
function knownSecretValues(): string[] {
|
|
320
|
+
const now = Date.now();
|
|
321
|
+
if (valuesCache && now - valuesCache.at < 5_000) return valuesCache.values;
|
|
322
|
+
const file = readFileSafe();
|
|
323
|
+
const values: string[] = [];
|
|
324
|
+
let key: Buffer;
|
|
325
|
+
try {
|
|
326
|
+
key = loadKey();
|
|
327
|
+
} catch {
|
|
328
|
+
return [];
|
|
329
|
+
}
|
|
330
|
+
for (const [name, entry] of Object.entries(file.secrets)) {
|
|
331
|
+
try {
|
|
332
|
+
const value = decryptValue(name, entry, key);
|
|
333
|
+
if (value.length >= 4) values.push(value);
|
|
334
|
+
} catch {
|
|
335
|
+
// повреждённая запись пропускается
|
|
336
|
+
}
|
|
337
|
+
}
|
|
338
|
+
// Длинные значения первыми, чтобы не оставить хвост после короткой замены.
|
|
339
|
+
values.sort((a, b) => b.length - a.length);
|
|
340
|
+
valuesCache = { at: now, values };
|
|
341
|
+
return values;
|
|
342
|
+
}
|
|
343
|
+
|
|
344
|
+
/**
|
|
345
|
+
* Вырезает из произвольного текста известные значения секретов и типовые
|
|
346
|
+
* присваивания вида `TOKEN=...` / `password: ...`.
|
|
347
|
+
*/
|
|
348
|
+
export function redactSecretsInText(text: unknown): string {
|
|
349
|
+
const source = typeof text === "string" ? text : String(text ?? "");
|
|
350
|
+
if (!source) return source;
|
|
351
|
+
let result = source;
|
|
352
|
+
|
|
353
|
+
// Защищаем ссылки ${secret:NAME} от общих правил маскировки: слово "secret"
|
|
354
|
+
// попадает под чувствительные ключи и ломало бы ссылки.
|
|
355
|
+
const protectedRefs: string[] = [];
|
|
356
|
+
result = result.replace(SECRET_REF_RE, (_match: string, name: string) => {
|
|
357
|
+
const placeholder = `\u0000SECRET_REF_${protectedRefs.length}\u0000`;
|
|
358
|
+
protectedRefs.push(`\${secret:${name}}`);
|
|
359
|
+
return placeholder;
|
|
360
|
+
});
|
|
361
|
+
|
|
362
|
+
for (const value of knownSecretValues()) {
|
|
363
|
+
if (!value) continue;
|
|
364
|
+
result = result.split(value).join("***");
|
|
365
|
+
}
|
|
366
|
+
|
|
367
|
+
result = result.replace(
|
|
368
|
+
/\b([A-Za-z0-9_]*(?:TOKEN|SECRET|PASSWORD|PASSWD|API_KEY|APIKEY|CREDENTIAL|AUTH)[A-Za-z0-9_]*)\b(\s*[=:]\s*)(["']?)([^\s"',;]+)\3/gi,
|
|
369
|
+
(_match: string, key: string, sep: string, quote: string) => `${key}${sep}${quote}***${quote}`
|
|
370
|
+
);
|
|
371
|
+
|
|
372
|
+
// Восстанавливаем защищённые ссылки.
|
|
373
|
+
for (let i = 0; i < protectedRefs.length; i++) {
|
|
374
|
+
result = result.split(`\u0000SECRET_REF_${i}\u0000`).join(protectedRefs[i]);
|
|
375
|
+
}
|
|
376
|
+
|
|
377
|
+
return result;
|
|
378
|
+
}
|
|
379
|
+
|
|
380
|
+
/** Сбрасывает кэши (для тестов и после ручного изменения файлов). */
|
|
381
|
+
export function resetSecretsCache(): void {
|
|
382
|
+
cache = null;
|
|
383
|
+
keyCache = null;
|
|
384
|
+
valuesCache = null;
|
|
385
|
+
}
|