opencode-windows-scheduler 1.2.3 → 1.4.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 +61 -2
- package/README.md +21 -4
- package/ROADMAP-STRATEGY.md +61 -159
- package/ROADMAP.md +60 -98
- 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/native-notify.d.ts +36 -0
- package/dist/core/native-notify.d.ts.map +1 -0
- package/dist/core/native-notify.js +110 -0
- package/dist/core/record-history.js +4 -4
- 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/telegram.d.ts +45 -0
- package/dist/core/telegram.d.ts.map +1 -0
- package/dist/core/telegram.js +160 -0
- package/dist/db/schema.d.ts +1 -1
- package/dist/db/schema.d.ts.map +1 -1
- package/dist/db/schema.js +15 -0
- package/dist/index.d.ts +30 -4
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +349 -22
- package/dist/notifications.d.ts +26 -6
- package/dist/notifications.d.ts.map +1 -1
- package/dist/notifications.js +191 -34
- package/dist/rpc.d.ts +400 -0
- package/dist/rpc.d.ts.map +1 -1
- package/dist/rpc.js +146 -0
- package/dist/server.d.ts.map +1 -1
- package/dist/server.js +67 -0
- package/dist/settings.d.ts +63 -2
- package/dist/settings.d.ts.map +1 -1
- package/dist/settings.js +126 -2
- 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 +16 -6
- package/docs/FEATURES.md +57 -12
- package/docs/README.ru.md +23 -4
- package/gui-experimental.cjs +4 -4
- package/package.json +5 -2
- package/src/core/audit.ts +291 -0
- package/src/core/native-notify.ts +154 -0
- package/src/core/record-history.ts +6 -4
- package/src/core/secrets.ts +385 -0
- package/src/core/structured-log.ts +9 -0
- package/src/core/telegram.ts +219 -0
- package/src/db/schema.ts +15 -0
- package/src/gui.tsx +543 -6
- package/src/index.ts +459 -22
- package/src/notifications.ts +232 -40
- package/src/rpc.ts +157 -0
- package/src/server.ts +67 -0
- package/src/settings.ts +213 -4
- package/src/workspaces.ts +22 -4
|
@@ -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
|
+
}
|
|
@@ -1,6 +1,7 @@
|
|
|
1
1
|
import fs from "node:fs";
|
|
2
2
|
import path from "node:path";
|
|
3
3
|
import { LOG_DIR } from "../types.js";
|
|
4
|
+
import { redactSecretsInText } from "./secrets.js";
|
|
4
5
|
|
|
5
6
|
/**
|
|
6
7
|
* Машиночитаемые логи запусков (Спринт 22).
|
|
@@ -120,6 +121,14 @@ export function appendStructuredLog(
|
|
|
120
121
|
...record,
|
|
121
122
|
ts: record.ts ?? new Date().toISOString(),
|
|
122
123
|
};
|
|
124
|
+
// Спринт 26: даже если ошибка пришла из внешнего процесса, известные
|
|
125
|
+
// значения секретов и присваивания TOKEN=/password: вырезаются.
|
|
126
|
+
if (typeof payload.error === "string") {
|
|
127
|
+
payload.error = redactSecretsInText(payload.error);
|
|
128
|
+
}
|
|
129
|
+
if (typeof payload.reason === "string") {
|
|
130
|
+
payload.reason = redactSecretsInText(payload.reason);
|
|
131
|
+
}
|
|
123
132
|
fs.appendFileSync(STRUCTURED_LOG_FILE, `${JSON.stringify(payload)}\n`, "utf8");
|
|
124
133
|
return true;
|
|
125
134
|
} catch (err) {
|
|
@@ -0,0 +1,219 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Telegram Bot API: отправка уведомлений (Спринт 25).
|
|
3
|
+
*
|
|
4
|
+
* Модуль намеренно не зависит от настроек и сетевого слоя приложения:
|
|
5
|
+
* всё, что нужно, передаётся аргументами. Это позволяет тестировать
|
|
6
|
+
* экранирование и сборку запроса без реальных вызовов Telegram.
|
|
7
|
+
*/
|
|
8
|
+
export type TelegramParseMode = "" | "HTML" | "Markdown" | "MarkdownV2";
|
|
9
|
+
|
|
10
|
+
/** Таймаут запроса по умолчанию. */
|
|
11
|
+
const DEFAULT_TIMEOUT_MS = 10_000;
|
|
12
|
+
|
|
13
|
+
export interface TelegramSendOptions {
|
|
14
|
+
/** База API; по умолчанию https://api.telegram.org. */
|
|
15
|
+
apiBase?: string;
|
|
16
|
+
/** Разметка; пусто — plain text. */
|
|
17
|
+
parseMode?: TelegramParseMode;
|
|
18
|
+
/** Отправить без звука. */
|
|
19
|
+
disableNotification?: boolean;
|
|
20
|
+
/** ID темы форума, если указан. */
|
|
21
|
+
messageThreadId?: number | null;
|
|
22
|
+
/** Добавить ссылку на дашборд. */
|
|
23
|
+
includeDashboardLink?: boolean;
|
|
24
|
+
/** URL дашборда; null/пусто — ссылка не добавляется. */
|
|
25
|
+
dashboardUrl?: string | null;
|
|
26
|
+
/** Таймаут запроса в мс. */
|
|
27
|
+
timeoutMs?: number;
|
|
28
|
+
/** Подмена fetch для тестов. */
|
|
29
|
+
fetchImpl?: typeof fetch;
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
/** Экранирует текст под выбранный parse_mode. */
|
|
33
|
+
export function escapeTelegramText(
|
|
34
|
+
text: string,
|
|
35
|
+
parseMode: TelegramParseMode = ""
|
|
36
|
+
): string {
|
|
37
|
+
const value = String(text ?? "");
|
|
38
|
+
if (parseMode === "HTML") {
|
|
39
|
+
return value
|
|
40
|
+
.replace(/&/g, "&")
|
|
41
|
+
.replace(/</g, "<")
|
|
42
|
+
.replace(/>/g, ">");
|
|
43
|
+
}
|
|
44
|
+
if (parseMode === "MarkdownV2") {
|
|
45
|
+
return value.replace(/([\\_*[\]()~`>#+\-=|{}.!])/g, "\\$1");
|
|
46
|
+
}
|
|
47
|
+
if (parseMode === "Markdown") {
|
|
48
|
+
return value.replace(/([\\_*[\]`])/g, "\\$1");
|
|
49
|
+
}
|
|
50
|
+
return value;
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
/** Экранирует URL для HTML-атрибута. */
|
|
54
|
+
function escapeHtmlAttribute(url: string): string {
|
|
55
|
+
return url
|
|
56
|
+
.replace(/&/g, "&")
|
|
57
|
+
.replace(/</g, "<")
|
|
58
|
+
.replace(/>/g, ">")
|
|
59
|
+
.replace(/"/g, """)
|
|
60
|
+
.replace(/'/g, "'");
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
/**
|
|
64
|
+
* Готовит текст сообщения: экранирует пользовательские данные и добавляет
|
|
65
|
+
* ссылку на дашборд в разметке выбранного режима.
|
|
66
|
+
*/
|
|
67
|
+
export function formatTelegramText(
|
|
68
|
+
text: string,
|
|
69
|
+
parseMode: TelegramParseMode = "",
|
|
70
|
+
dashboardUrl?: string | null
|
|
71
|
+
): string {
|
|
72
|
+
const body = escapeTelegramText(text, parseMode);
|
|
73
|
+
const url = (dashboardUrl ?? "").trim();
|
|
74
|
+
if (!url) return body;
|
|
75
|
+
|
|
76
|
+
if (parseMode === "HTML") {
|
|
77
|
+
return `${body}\n\n<a href="${escapeHtmlAttribute(url)}">📊 Открыть дашборд</a>`;
|
|
78
|
+
}
|
|
79
|
+
if (parseMode === "MarkdownV2") {
|
|
80
|
+
const escapedUrl = url.replace(/[)\\]/g, "\\$&");
|
|
81
|
+
return `${body}\n\n[📊 Открыть дашборд](${escapedUrl})`;
|
|
82
|
+
}
|
|
83
|
+
if (parseMode === "Markdown") {
|
|
84
|
+
const escapedUrl = url.replace(/[)]/g, "\\)");
|
|
85
|
+
return `${body}\n\n[📊 Открыть дашборд](${escapedUrl})`;
|
|
86
|
+
}
|
|
87
|
+
return `${body}\n\n📊 Открыть дашборд: ${url}`;
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
/** Проверяет формат токена бота; возвращает trimmed-значение. */
|
|
91
|
+
export function validateTelegramToken(token: string): string {
|
|
92
|
+
const value = (token ?? "").trim();
|
|
93
|
+
if (!value) {
|
|
94
|
+
throw new Error("Не задан токен Telegram-бота.");
|
|
95
|
+
}
|
|
96
|
+
// Формат BotFather: <digits>:<base64-ish>. Проверяем достаточно мягко,
|
|
97
|
+
// чтобы не ломать тестовые токены, но отсекать явный мусор.
|
|
98
|
+
if (!/^\d+:[A-Za-z0-9_-]{5,}$/.test(value)) {
|
|
99
|
+
throw new Error("Некорректный токен Telegram-бота.");
|
|
100
|
+
}
|
|
101
|
+
return value;
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
/** Маскирует токен для сообщений об ошибках и логов. */
|
|
105
|
+
export function maskTelegramToken(token: string): string {
|
|
106
|
+
const value = (token ?? "").trim();
|
|
107
|
+
if (!value) return "***";
|
|
108
|
+
const colon = value.indexOf(":");
|
|
109
|
+
if (colon <= 0) return "***";
|
|
110
|
+
const id = value.slice(0, colon);
|
|
111
|
+
const secret = value.slice(colon + 1);
|
|
112
|
+
const tail = secret.length >= 4 ? secret.slice(-4) : "";
|
|
113
|
+
return `${id}:***${tail}`;
|
|
114
|
+
}
|
|
115
|
+
|
|
116
|
+
/** Убирает токен из произвольного текста ошибки. */
|
|
117
|
+
function sanitizeErrorText(text: string, token: string): string {
|
|
118
|
+
if (!text) return text;
|
|
119
|
+
return text.split(token).join(maskTelegramToken(token));
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
function resolveApiBase(apiBase?: string): string {
|
|
123
|
+
const value = (apiBase ?? "https://api.telegram.org").trim().replace(/\/+$/, "");
|
|
124
|
+
let parsed: URL;
|
|
125
|
+
try {
|
|
126
|
+
parsed = new URL(value);
|
|
127
|
+
} catch {
|
|
128
|
+
throw new Error("Некорректный адрес Telegram API.");
|
|
129
|
+
}
|
|
130
|
+
if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
|
|
131
|
+
throw new Error("Telegram API поддерживает только http:// или https://.");
|
|
132
|
+
}
|
|
133
|
+
return value;
|
|
134
|
+
}
|
|
135
|
+
|
|
136
|
+
/**
|
|
137
|
+
* Отправляет сообщение через Bot API `sendMessage`.
|
|
138
|
+
*
|
|
139
|
+
* Бросает Error с безопасным текстом (токен замаскирован). Вызывающий код
|
|
140
|
+
* обязан перехватить ошибку, чтобы уведомление не ломало задачу.
|
|
141
|
+
*/
|
|
142
|
+
export async function sendTelegramMessage(
|
|
143
|
+
token: string,
|
|
144
|
+
chatId: string,
|
|
145
|
+
text: string,
|
|
146
|
+
options: TelegramSendOptions = {}
|
|
147
|
+
): Promise<void> {
|
|
148
|
+
const safeToken = validateTelegramToken(token);
|
|
149
|
+
const target = (chatId ?? "").trim();
|
|
150
|
+
if (!target) {
|
|
151
|
+
throw new Error("Не задан chat_id Telegram.");
|
|
152
|
+
}
|
|
153
|
+
|
|
154
|
+
const apiBase = resolveApiBase(options.apiBase);
|
|
155
|
+
const parseMode = options.parseMode ?? "";
|
|
156
|
+
const body: Record<string, unknown> = {
|
|
157
|
+
chat_id: target,
|
|
158
|
+
text: formatTelegramText(
|
|
159
|
+
text,
|
|
160
|
+
parseMode,
|
|
161
|
+
options.includeDashboardLink === false ? null : options.dashboardUrl
|
|
162
|
+
),
|
|
163
|
+
};
|
|
164
|
+
if (parseMode) body.parse_mode = parseMode;
|
|
165
|
+
if (options.disableNotification) body.disable_notification = true;
|
|
166
|
+
if (
|
|
167
|
+
typeof options.messageThreadId === "number" &&
|
|
168
|
+
Number.isFinite(options.messageThreadId) &&
|
|
169
|
+
options.messageThreadId > 0
|
|
170
|
+
) {
|
|
171
|
+
body.message_thread_id = Math.floor(options.messageThreadId);
|
|
172
|
+
}
|
|
173
|
+
|
|
174
|
+
const timeoutMs = Math.max(
|
|
175
|
+
1_000,
|
|
176
|
+
Math.floor(options.timeoutMs ?? DEFAULT_TIMEOUT_MS)
|
|
177
|
+
);
|
|
178
|
+
const fetchImpl = options.fetchImpl ?? fetch;
|
|
179
|
+
const controller = new AbortController();
|
|
180
|
+
const timer = setTimeout(() => controller.abort(), timeoutMs);
|
|
181
|
+
|
|
182
|
+
try {
|
|
183
|
+
const response = await fetchImpl(
|
|
184
|
+
`${apiBase}/bot${safeToken}/sendMessage`,
|
|
185
|
+
{
|
|
186
|
+
method: "POST",
|
|
187
|
+
headers: { "Content-Type": "application/json" },
|
|
188
|
+
body: JSON.stringify(body),
|
|
189
|
+
signal: controller.signal,
|
|
190
|
+
}
|
|
191
|
+
);
|
|
192
|
+
|
|
193
|
+
const raw = await response.text().catch(() => "");
|
|
194
|
+
let parsed: any = null;
|
|
195
|
+
try {
|
|
196
|
+
parsed = raw ? JSON.parse(raw) : null;
|
|
197
|
+
} catch {
|
|
198
|
+
parsed = null;
|
|
199
|
+
}
|
|
200
|
+
|
|
201
|
+
if (!response.ok || parsed?.ok === false) {
|
|
202
|
+
const description =
|
|
203
|
+
(typeof parsed?.description === "string" && parsed.description) ||
|
|
204
|
+
raw.slice(0, 200) ||
|
|
205
|
+
`HTTP ${response.status}`;
|
|
206
|
+
throw new Error(
|
|
207
|
+
`Telegram API: ${sanitizeErrorText(description, safeToken)}`
|
|
208
|
+
);
|
|
209
|
+
}
|
|
210
|
+
} catch (err: any) {
|
|
211
|
+
if (err?.name === "AbortError") {
|
|
212
|
+
throw new Error(`Таймаут Telegram API (${Math.floor(timeoutMs / 1000)} с).`);
|
|
213
|
+
}
|
|
214
|
+
const message = err instanceof Error ? err.message : String(err);
|
|
215
|
+
throw new Error(sanitizeErrorText(message, safeToken));
|
|
216
|
+
} finally {
|
|
217
|
+
clearTimeout(timer);
|
|
218
|
+
}
|
|
219
|
+
}
|
package/src/db/schema.ts
CHANGED
|
@@ -67,6 +67,21 @@ CREATE TABLE IF NOT EXISTS workspaces (
|
|
|
67
67
|
env_file TEXT,
|
|
68
68
|
created_at TEXT NOT NULL
|
|
69
69
|
);
|
|
70
|
+
|
|
71
|
+
CREATE TABLE IF NOT EXISTS audit_log (
|
|
72
|
+
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
73
|
+
ts TEXT NOT NULL,
|
|
74
|
+
action TEXT NOT NULL,
|
|
75
|
+
target_type TEXT,
|
|
76
|
+
target TEXT,
|
|
77
|
+
actor TEXT NOT NULL,
|
|
78
|
+
source TEXT,
|
|
79
|
+
details_json TEXT,
|
|
80
|
+
remote TEXT
|
|
81
|
+
);
|
|
82
|
+
|
|
83
|
+
CREATE INDEX IF NOT EXISTS idx_audit_ts ON audit_log(ts DESC);
|
|
84
|
+
CREATE INDEX IF NOT EXISTS idx_audit_action ON audit_log(action, ts DESC);
|
|
70
85
|
`;
|
|
71
86
|
|
|
72
87
|
interface SchemaDb {
|