@itphx/synth-storage-postgres 0.0.0-stage → 0.11.3

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.
Files changed (72) hide show
  1. package/LICENSE +18 -0
  2. package/LICENSE.ru.md +31 -0
  3. package/dist/errors.d.ts +71 -0
  4. package/dist/errors.js +126 -0
  5. package/dist/index.d.ts +37 -0
  6. package/dist/index.js +34 -0
  7. package/dist/json-param.d.ts +14 -0
  8. package/dist/json-param.js +22 -0
  9. package/dist/locks.d.ts +104 -0
  10. package/dist/locks.js +201 -0
  11. package/dist/migrate.d.ts +58 -0
  12. package/dist/migrate.js +125 -0
  13. package/dist/migrations/001-init.d.ts +15 -0
  14. package/dist/migrations/001-init.js +457 -0
  15. package/dist/migrations/002-egress-audit.d.ts +12 -0
  16. package/dist/migrations/002-egress-audit.js +52 -0
  17. package/dist/migrations/003-analytics-rollups.d.ts +12 -0
  18. package/dist/migrations/003-analytics-rollups.js +21 -0
  19. package/dist/migrations/index.d.ts +23 -0
  20. package/dist/migrations/index.js +23 -0
  21. package/dist/pool.d.ts +178 -0
  22. package/dist/pool.js +382 -0
  23. package/dist/ports/analytics.d.ts +26 -0
  24. package/dist/ports/analytics.js +243 -0
  25. package/dist/ports/audit.d.ts +15 -0
  26. package/dist/ports/audit.js +189 -0
  27. package/dist/ports/content.d.ts +41 -0
  28. package/dist/ports/content.js +1539 -0
  29. package/dist/ports/core-sync.d.ts +31 -0
  30. package/dist/ports/core-sync.js +34 -0
  31. package/dist/ports/deps.d.ts +63 -0
  32. package/dist/ports/deps.js +19 -0
  33. package/dist/ports/events-bindings.d.ts +77 -0
  34. package/dist/ports/events-bindings.js +356 -0
  35. package/dist/ports/events-core.d.ts +35 -0
  36. package/dist/ports/events-core.js +71 -0
  37. package/dist/ports/events-journal.d.ts +68 -0
  38. package/dist/ports/events-journal.js +211 -0
  39. package/dist/ports/events-scheduler.d.ts +49 -0
  40. package/dist/ports/events-scheduler.js +231 -0
  41. package/dist/ports/events-webhooks.d.ts +64 -0
  42. package/dist/ports/events-webhooks.js +268 -0
  43. package/dist/ports/events.d.ts +20 -0
  44. package/dist/ports/events.js +27 -0
  45. package/dist/ports/principals-defaults.d.ts +21 -0
  46. package/dist/ports/principals-defaults.js +68 -0
  47. package/dist/ports/principals-documents.d.ts +23 -0
  48. package/dist/ports/principals-documents.js +38 -0
  49. package/dist/ports/principals-profiles.d.ts +21 -0
  50. package/dist/ports/principals-profiles.js +263 -0
  51. package/dist/ports/principals-projects.d.ts +19 -0
  52. package/dist/ports/principals-projects.js +158 -0
  53. package/dist/ports/principals-settings.d.ts +25 -0
  54. package/dist/ports/principals-settings.js +275 -0
  55. package/dist/ports/principals-shared.d.ts +33 -0
  56. package/dist/ports/principals-shared.js +44 -0
  57. package/dist/ports/principals.d.ts +27 -0
  58. package/dist/ports/principals.js +39 -0
  59. package/dist/ports/sessions-mapping.d.ts +237 -0
  60. package/dist/ports/sessions-mapping.js +405 -0
  61. package/dist/ports/sessions.d.ts +133 -0
  62. package/dist/ports/sessions.js +502 -0
  63. package/dist/ports/stub.d.ts +14 -0
  64. package/dist/ports/stub.js +32 -0
  65. package/dist/postgres-storage.d.ts +59 -0
  66. package/dist/postgres-storage.js +111 -0
  67. package/dist/schema.d.ts +13 -0
  68. package/dist/schema.js +22 -0
  69. package/dist/storage-context.d.ts +51 -0
  70. package/dist/storage-context.js +130 -0
  71. package/package.json +40 -3
  72. package/README.md +0 -3
@@ -0,0 +1,1539 @@
1
+ /**
2
+ * Группа портов **контента, секретов и обслуживания** PostgreSQL-драйвера
3
+ * (PROP-032, волна 3b).
4
+ *
5
+ * Владелец файла — один агент волны реализации; правит только `content.ts`.
6
+ * Файл экспортирует единственную фабрику `buildContentPorts(deps)`, возвращающую
7
+ * свою часть `StorageContext`: `serviceKeys`, `sshKeys`, `mcpRegistry`,
8
+ * `skillBundles`, `dictionaries`, `secretPatterns`, `protectedPaths`,
9
+ * `maintenanceAudit`.
10
+ *
11
+ * ── Синхронные геттеры (кэш-фасад) ────────────────────────────────────────
12
+ * `secretPatterns`/`protectedPaths`/`dictionaries` требуют **синхронных** вызовов
13
+ * на горячем пути (сборка промпта, детекция секретов, маршрутизация). Поэтому:
14
+ * - «системный» слой (дефолтные паттерны, definitions/protected-paths.json,
15
+ * системные словари) читается **синхронно** из ассетов core либо из
16
+ * инстанс-конфигурации — он доступен сразу, без обращения к БД;
17
+ * - пользовательский override — в таблице `settings(key, value jsonb)`
18
+ * (схема `001-init` общих таблиц для словарей/паттернов/путей НЕ заводит);
19
+ * он прогревается в память асинхронно при сборке контекста (best-effort
20
+ * warm) и поддерживается **write-through** при мутациях.
21
+ *
22
+ * Известное ограничение: кэш синхронных геттеров процесс-локальный — правки
23
+ * override другим процессом/инстансом он не увидит до рестарта; короткое окно
24
+ * сразу после старта может отдать системный дефолт до завершения прогрева.
25
+ *
26
+ * ── Core на синхронном пути ───────────────────────────────────────────────
27
+ * Синхронным геттерам нужны данные/хелперы core (`DEFAULT_PATTERNS`,
28
+ * `definitions/protected-paths.json`, системные словари). Прямой доступ к core
29
+ * невозможен: core — `peerDependencies`, а статический рантайм-импорт образовал бы
30
+ * цикл. Поэтому core **инъектирует** значения в конфиг драйвера
31
+ * (`PortDeps.coreSync`, сборка — `packages/core/src/storage/storage-context.ts`);
32
+ * без инъекции (прямой вызов фабрики) они собираются ленивым
33
+ * `import('@itphx/synth-core')` в `core-sync.ts`. Асинхронные методы (шифрование
34
+ * at-rest в `sshKeys`) грузят core тем же ленивым `import()` внутри функций.
35
+ */
36
+ import { join, normalize } from 'node:path';
37
+ import { createHash, randomBytes } from 'node:crypto';
38
+ import { GlobalRole, MCP_REGISTRY_SCHEMA_VERSION, SKILL_NAME_MAX, SKILL_NAME_REGEX, generateId, nowISO, } from '@itphx/synth-shared';
39
+ import { jsonbParam } from '../json-param.js';
40
+ import { PostgresUniqueViolationError } from '../errors.js';
41
+ import { readSchemaVersion } from '../migrate.js';
42
+ /** Роль по умолчанию для service-key (least privilege). */
43
+ const DEFAULT_SERVICE_KEY_ROLES = [GlobalRole.USER];
44
+ let coreAsyncCache = null;
45
+ /** Ленивая загрузка core для асинхронных методов (без статического импорта). */
46
+ function loadCore() {
47
+ if (!coreAsyncCache) {
48
+ coreAsyncCache = import('@itphx/synth-core').catch((err) => {
49
+ coreAsyncCache = null;
50
+ throw err;
51
+ });
52
+ }
53
+ return coreAsyncCache;
54
+ }
55
+ /** ISO-строка из значения timestamptz (pg отдаёт `Date`) либо строки. */
56
+ function toISO(value) {
57
+ if (value instanceof Date)
58
+ return value.toISOString();
59
+ if (typeof value === 'string')
60
+ return value;
61
+ return String(value);
62
+ }
63
+ /** ISO-строка или `undefined` для nullable-поля. */
64
+ function toISOOrUndefined(value) {
65
+ return value === null || value === undefined ? undefined : toISO(value);
66
+ }
67
+ /** Массив строк из jsonb/`text[]` (невалидные элементы отбрасываются). */
68
+ function asStringArray(value) {
69
+ if (!Array.isArray(value))
70
+ return [];
71
+ return value.filter((item) => typeof item === 'string');
72
+ }
73
+ function asRoles(value) {
74
+ return asStringArray(value);
75
+ }
76
+ /** Параметр jsonb: сериализуем сами (pg сериализует массивы как Postgres-массивы). */
77
+ function jsonParam(value) {
78
+ return jsonbParam(value) ?? 'null';
79
+ }
80
+ /** Upsert ключа `settings(key, value jsonb)`. */
81
+ async function saveSetting(tx, key, value) {
82
+ await tx.query(`INSERT INTO settings (key, value, updated_at) VALUES ($1, $2::jsonb, now())
83
+ ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now()`, [key, jsonParam(value)]);
84
+ }
85
+ async function loadSetting(tx, key) {
86
+ const rows = await tx.query('SELECT value FROM settings WHERE key = $1', [key]);
87
+ const row = rows[0];
88
+ return row ? row.value : null;
89
+ }
90
+ async function deleteSetting(tx, key) {
91
+ const rows = await tx.query('DELETE FROM settings WHERE key = $1 RETURNING key', [key]);
92
+ return rows.length > 0;
93
+ }
94
+ /** Best-effort лог драйвера (не роняет сборку контекста). */
95
+ function warnStorage(message) {
96
+ void loadCore()
97
+ .then((core) => core.warning('STORAGE', `postgres: ${message}`))
98
+ .catch(() => undefined);
99
+ }
100
+ /** Best-effort лог прогрева порта (не роняет сборку контекста). */
101
+ function warnWarm(port, err) {
102
+ const message = err instanceof Error ? err.message : String(err);
103
+ warnStorage(`прогрев порта '${port}' не удался: ${message}`);
104
+ }
105
+ /**
106
+ * Best-effort прогрев синхронных кэшей (`secretPatterns`/`protectedPaths`/
107
+ * `dictionaries`) из `settings`.
108
+ *
109
+ * Перед прогревом **один раз** проверяется версия схемы: если таблицы миграций
110
+ * ещё нет (схема не инициализирована — напр. диагностика `doctor` с
111
+ * `postgresSchemaMode:'skip'` до `synth migrate`), прогрев пропускается с
112
+ * **одним** понятным предупреждением, а не пачкой ошибок `relation "settings"
113
+ * does not exist` по каждому порту. Прогрев никогда не роняет сборку контекста.
114
+ */
115
+ async function warmContentCaches(deps, ports) {
116
+ let schemaVersion;
117
+ try {
118
+ schemaVersion = await readSchemaVersion(deps.connection, deps.connection.schema);
119
+ }
120
+ catch (err) {
121
+ const message = err instanceof Error ? err.message : String(err);
122
+ warnStorage(`не удалось проверить схему хранилища: ${message}`);
123
+ return;
124
+ }
125
+ if (schemaVersion === null) {
126
+ warnStorage('хранилище не инициализировано — выполните `synth migrate`');
127
+ return;
128
+ }
129
+ await Promise.all([
130
+ ports.secretPatterns.warm().catch((err) => warnWarm('secretPatterns', err)),
131
+ ports.protectedPaths.warm().catch((err) => warnWarm('protectedPaths', err)),
132
+ ports.dictionaries.warm().catch((err) => warnWarm('dictionaries', err)),
133
+ ]);
134
+ }
135
+ // ────────────────────────────────────────────────────────────────────────────
136
+ // serviceKeys (ADR-052)
137
+ // ────────────────────────────────────────────────────────────────────────────
138
+ /** Длина видимой части секрета в `prefix` (`synth_svc_abcd…`) — деталь отображения. */
139
+ const SECRET_PREFIX_VISIBLE = 12;
140
+ function hashSecret(secret) {
141
+ return createHash('sha256').update(secret).digest('hex');
142
+ }
143
+ function serviceKeyToPublic(row) {
144
+ const key = {
145
+ id: row.id,
146
+ label: row.label,
147
+ roles: asRoles(row.roles),
148
+ scopes: asStringArray(row.scopes),
149
+ createdBy: row.created_by,
150
+ createdAt: toISO(row.created_at),
151
+ prefix: row.prefix,
152
+ };
153
+ if (row.description !== null)
154
+ key.description = row.description;
155
+ if (row.allowed_projects !== null)
156
+ key.allowedProjects = asStringArray(row.allowed_projects);
157
+ if (row.rate_limit_per_minute !== null)
158
+ key.rateLimitPerMinute = row.rate_limit_per_minute;
159
+ const expiresAt = toISOOrUndefined(row.expires_at);
160
+ if (expiresAt !== undefined)
161
+ key.expiresAt = expiresAt;
162
+ const revokedAt = toISOOrUndefined(row.revoked_at);
163
+ if (revokedAt !== undefined)
164
+ key.revokedAt = revokedAt;
165
+ const lastUsedAt = toISOOrUndefined(row.last_used_at);
166
+ if (lastUsedAt !== undefined)
167
+ key.lastUsedAt = lastUsedAt;
168
+ return key;
169
+ }
170
+ /** Внутренняя запись для переноса между backend'ами: публичные поля + sha256-хеш. */
171
+ function serviceKeyToRecord(row) {
172
+ return { ...serviceKeyToPublic(row), hash: row.secret_hash };
173
+ }
174
+ /** Порт реестра service-key инстанса поверх таблицы `service_keys`. */
175
+ class PostgresServiceKeyRepository {
176
+ _deps;
177
+ constructor(_deps) {
178
+ this._deps = _deps;
179
+ }
180
+ _db() {
181
+ return this._deps.connection;
182
+ }
183
+ async list() {
184
+ const rows = await this._db().query('SELECT * FROM service_keys ORDER BY created_at ASC');
185
+ return rows.map(serviceKeyToPublic);
186
+ }
187
+ async get(id) {
188
+ const rows = await this._db().query('SELECT * FROM service_keys WHERE id = $1', [id]);
189
+ const row = rows[0];
190
+ return row ? serviceKeyToPublic(row) : null;
191
+ }
192
+ /** Полные записи (включая `secret_hash`) — только для переноса между backend'ами. */
193
+ async exportAll() {
194
+ const rows = await this._db().query('SELECT * FROM service_keys ORDER BY created_at ASC');
195
+ return rows.map(serviceKeyToRecord);
196
+ }
197
+ /**
198
+ * Импорт готовой записи как есть (PROP-032): `id`/`prefix`/`secret_hash`
199
+ * сохраняются. `ON CONFLICT DO NOTHING` — идемпотентно; при конфликте
200
+ * возвращается существующая строка (по `id`, метке или хешу).
201
+ */
202
+ async importExisting(record) {
203
+ const label = record.label?.trim() ?? '';
204
+ if (!record.id)
205
+ throw new Error('id обязателен');
206
+ if (!label)
207
+ throw new Error('label обязателен');
208
+ if (!record.hash)
209
+ throw new Error('hash обязателен');
210
+ const inserted = await this._db().query(`INSERT INTO service_keys
211
+ (id, label, description, roles, scopes, allowed_projects, rate_limit_per_minute,
212
+ secret_hash, prefix, created_by, created_at, last_used_at, expires_at, revoked_at)
213
+ VALUES ($1,$2,$3,$4::jsonb,$5::jsonb,$6::jsonb,$7,$8,$9,$10,$11,$12,$13,$14)
214
+ ON CONFLICT DO NOTHING
215
+ RETURNING *`, [
216
+ record.id,
217
+ label,
218
+ record.description ?? null,
219
+ jsonParam(record.roles),
220
+ jsonParam(record.scopes),
221
+ record.allowedProjects !== undefined ? jsonParam(record.allowedProjects) : null,
222
+ record.rateLimitPerMinute ?? null,
223
+ record.hash,
224
+ record.prefix,
225
+ record.createdBy,
226
+ record.createdAt,
227
+ record.lastUsedAt ?? null,
228
+ record.expiresAt ?? null,
229
+ record.revokedAt ?? null,
230
+ ]);
231
+ if (inserted[0])
232
+ return serviceKeyToPublic(inserted[0]);
233
+ const existing = await this._db().query(`SELECT * FROM service_keys
234
+ WHERE id = $1 OR lower(label) = lower($2) OR secret_hash = $3
235
+ ORDER BY CASE WHEN id = $1 THEN 0 WHEN lower(label) = lower($2) THEN 1 ELSE 2 END
236
+ LIMIT 1`, [record.id, label, record.hash]);
237
+ if (!existing[0])
238
+ throw new Error(`service-key ${record.id} не импортирован (конфликт без записи)`);
239
+ return serviceKeyToPublic(existing[0]);
240
+ }
241
+ async _assertLabelUnique(label, excludeId) {
242
+ const rows = await this._db().query('SELECT id FROM service_keys WHERE lower(label) = lower($1) AND ($2::text IS NULL OR id <> $2) LIMIT 1', [label, excludeId ?? null]);
243
+ if (rows.length > 0) {
244
+ const { ServiceApiKeyConflictError } = await loadCore();
245
+ throw new ServiceApiKeyConflictError(label);
246
+ }
247
+ }
248
+ async create(input, createdBy) {
249
+ const { SERVICE_KEY_SECRET_PREFIX } = await loadCore();
250
+ const label = input.label?.trim() ?? '';
251
+ if (!label)
252
+ throw new Error('label обязателен');
253
+ await this._assertLabelUnique(label);
254
+ const secret = `${SERVICE_KEY_SECRET_PREFIX}${randomBytes(24).toString('base64url')}`;
255
+ const record = {
256
+ id: `svk_${generateId()}`,
257
+ label,
258
+ roles: input.roles && input.roles.length > 0 ? [...input.roles] : [...DEFAULT_SERVICE_KEY_ROLES],
259
+ scopes: [...input.scopes],
260
+ createdBy,
261
+ createdAt: nowISO(),
262
+ prefix: `${secret.slice(0, SECRET_PREFIX_VISIBLE)}…`,
263
+ };
264
+ if (input.description !== undefined)
265
+ record.description = input.description;
266
+ if (input.allowedProjects !== undefined)
267
+ record.allowedProjects = [...input.allowedProjects];
268
+ if (input.rateLimitPerMinute !== undefined)
269
+ record.rateLimitPerMinute = input.rateLimitPerMinute;
270
+ if (input.expiresAt !== undefined)
271
+ record.expiresAt = input.expiresAt;
272
+ try {
273
+ await this._db().query(`INSERT INTO service_keys
274
+ (id, label, description, roles, scopes, allowed_projects, rate_limit_per_minute,
275
+ secret_hash, prefix, created_by, created_at, expires_at)
276
+ VALUES ($1,$2,$3,$4::jsonb,$5::jsonb,$6::jsonb,$7,$8,$9,$10,$11,$12)`, [
277
+ record.id,
278
+ record.label,
279
+ record.description ?? null,
280
+ jsonParam(record.roles),
281
+ jsonParam(record.scopes),
282
+ record.allowedProjects !== undefined ? jsonParam(record.allowedProjects) : null,
283
+ record.rateLimitPerMinute ?? null,
284
+ hashSecret(secret),
285
+ record.prefix,
286
+ record.createdBy,
287
+ record.createdAt,
288
+ record.expiresAt ?? null,
289
+ ]);
290
+ }
291
+ catch (err) {
292
+ if (err instanceof PostgresUniqueViolationError) {
293
+ const { ServiceApiKeyConflictError } = await loadCore();
294
+ throw new ServiceApiKeyConflictError(label);
295
+ }
296
+ throw err;
297
+ }
298
+ return { ...record, key: secret };
299
+ }
300
+ async ensure(input) {
301
+ const { BOOTSTRAP_CREATED_BY, SERVICE_KEY_SECRET_PREFIX } = await loadCore();
302
+ const label = input.label?.trim() ?? '';
303
+ if (!label)
304
+ throw new Error('label обязателен');
305
+ const rawSecret = input.secret?.trim() ?? '';
306
+ if (!rawSecret)
307
+ throw new Error('secret обязателен');
308
+ const secret = rawSecret.startsWith(SERVICE_KEY_SECRET_PREFIX)
309
+ ? rawSecret
310
+ : `${SERVICE_KEY_SECRET_PREFIX}${rawSecret}`;
311
+ const roles = input.roles && input.roles.length > 0 ? [...input.roles] : [...DEFAULT_SERVICE_KEY_ROLES];
312
+ const existingRows = await this._db().query('SELECT * FROM service_keys WHERE lower(label) = lower($1) LIMIT 1', [label]);
313
+ const existing = existingRows[0];
314
+ if (!existing) {
315
+ const record = {
316
+ id: `svk_${generateId()}`,
317
+ label,
318
+ roles,
319
+ scopes: [...input.scopes],
320
+ createdBy: input.createdBy ?? BOOTSTRAP_CREATED_BY,
321
+ createdAt: nowISO(),
322
+ prefix: `${secret.slice(0, SECRET_PREFIX_VISIBLE)}…`,
323
+ };
324
+ if (input.description !== undefined)
325
+ record.description = input.description;
326
+ try {
327
+ await this._db().query(`INSERT INTO service_keys
328
+ (id, label, description, roles, scopes, secret_hash, prefix, created_by, created_at)
329
+ VALUES ($1,$2,$3,$4::jsonb,$5::jsonb,$6,$7,$8,$9)`, [
330
+ record.id,
331
+ record.label,
332
+ record.description ?? null,
333
+ jsonParam(record.roles),
334
+ jsonParam(record.scopes),
335
+ hashSecret(secret),
336
+ record.prefix,
337
+ record.createdBy,
338
+ record.createdAt,
339
+ ]);
340
+ }
341
+ catch (err) {
342
+ if (err instanceof PostgresUniqueViolationError) {
343
+ const { ServiceApiKeyConflictError } = await loadCore();
344
+ throw new ServiceApiKeyConflictError(label);
345
+ }
346
+ throw err;
347
+ }
348
+ return { status: 'created', key: record };
349
+ }
350
+ const current = serviceKeyToPublic(existing);
351
+ const sameScopes = current.scopes.length === input.scopes.length &&
352
+ current.scopes.every((s, i) => s === input.scopes[i]);
353
+ const sameRoles = !input.roles || input.roles.length === 0
354
+ ? true
355
+ : current.roles.length === roles.length && current.roles.every((r, i) => r === roles[i]);
356
+ if (sameScopes && sameRoles)
357
+ return { status: 'unchanged', key: current };
358
+ const nextScopes = sameScopes ? current.scopes : [...input.scopes];
359
+ const nextRoles = sameRoles ? current.roles : roles;
360
+ await this._db().query('UPDATE service_keys SET scopes = $2::jsonb, roles = $3::jsonb WHERE id = $1', [
361
+ current.id,
362
+ jsonParam(nextScopes),
363
+ jsonParam(nextRoles),
364
+ ]);
365
+ return { status: 'updated', key: { ...current, scopes: nextScopes, roles: nextRoles } };
366
+ }
367
+ async update(id, patch) {
368
+ const rows = await this._db().query('SELECT * FROM service_keys WHERE id = $1', [id]);
369
+ const existing = rows[0];
370
+ if (!existing)
371
+ return null;
372
+ const current = serviceKeyToPublic(existing);
373
+ const sets = [];
374
+ const params = [id];
375
+ const push = (column, value, cast = '') => {
376
+ params.push(value);
377
+ sets.push(`${column} = $${params.length}${cast}`);
378
+ };
379
+ if (patch.label !== undefined) {
380
+ const label = patch.label.trim();
381
+ if (!label)
382
+ throw new Error('label обязателен');
383
+ await this._assertLabelUnique(label, id);
384
+ push('label', label);
385
+ }
386
+ if (patch.description !== undefined)
387
+ push('description', patch.description === null ? null : patch.description);
388
+ if (patch.roles !== undefined) {
389
+ push('roles', jsonParam(patch.roles.length > 0 ? [...patch.roles] : [...DEFAULT_SERVICE_KEY_ROLES]), '::jsonb');
390
+ }
391
+ if (patch.scopes !== undefined)
392
+ push('scopes', jsonParam([...patch.scopes]), '::jsonb');
393
+ if (patch.allowedProjects !== undefined) {
394
+ push('allowed_projects', patch.allowedProjects === null ? null : jsonParam(patch.allowedProjects), '::jsonb');
395
+ }
396
+ if (patch.rateLimitPerMinute !== undefined)
397
+ push('rate_limit_per_minute', patch.rateLimitPerMinute);
398
+ if (patch.expiresAt !== undefined)
399
+ push('expires_at', patch.expiresAt);
400
+ if (sets.length === 0)
401
+ return current;
402
+ try {
403
+ await this._db().query(`UPDATE service_keys SET ${sets.join(', ')} WHERE id = $1`, params);
404
+ }
405
+ catch (err) {
406
+ if (err instanceof PostgresUniqueViolationError) {
407
+ const { ServiceApiKeyConflictError } = await loadCore();
408
+ throw new ServiceApiKeyConflictError(patch.label ?? '');
409
+ }
410
+ throw err;
411
+ }
412
+ return this.get(id);
413
+ }
414
+ async remove(id) {
415
+ const rows = await this._db().query('DELETE FROM service_keys WHERE id = $1 RETURNING id', [id]);
416
+ return rows.length > 0;
417
+ }
418
+ async revoke(id) {
419
+ const rows = await this._db().query('UPDATE service_keys SET revoked_at = COALESCE(revoked_at, now()) WHERE id = $1 RETURNING id', [id]);
420
+ return rows.length > 0;
421
+ }
422
+ async resolveBySecret(rawSecret) {
423
+ if (!rawSecret)
424
+ return null;
425
+ const rows = await this._db().query(`SELECT * FROM service_keys
426
+ WHERE secret_hash = $1
427
+ AND revoked_at IS NULL
428
+ AND (expires_at IS NULL OR expires_at > now())
429
+ LIMIT 1`, [hashSecret(rawSecret)]);
430
+ const row = rows[0];
431
+ if (!row)
432
+ return null;
433
+ const key = serviceKeyToPublic(row);
434
+ const credential = {
435
+ keyId: key.id,
436
+ label: key.label,
437
+ roles: [...key.roles],
438
+ scopes: [...key.scopes],
439
+ };
440
+ if (key.allowedProjects)
441
+ credential.allowedProjects = [...key.allowedProjects];
442
+ if (key.rateLimitPerMinute !== undefined)
443
+ credential.rateLimitPerMinute = key.rateLimitPerMinute;
444
+ return { key, credential };
445
+ }
446
+ async touch(id) {
447
+ await this._db().query('UPDATE service_keys SET last_used_at = now() WHERE id = $1', [id]);
448
+ }
449
+ }
450
+ function bufferToToken(value) {
451
+ return Buffer.isBuffer(value) ? value.toString('utf-8') : value;
452
+ }
453
+ function sshKeyToMeta(row, agentIds) {
454
+ const meta = {
455
+ id: row.id,
456
+ name: row.name,
457
+ type: row.type ?? 'user',
458
+ agentIds: [...agentIds],
459
+ createdAt: toISO(row.created_at),
460
+ };
461
+ const updatedAt = toISOOrUndefined(row.updated_at);
462
+ if (updatedAt !== undefined)
463
+ meta.updatedAt = updatedAt;
464
+ return meta;
465
+ }
466
+ function mapCryptoError(err, core) {
467
+ if (err instanceof core.SSHKeyStoreError)
468
+ return err;
469
+ if (err instanceof core.CryptoError) {
470
+ return new core.SSHKeyStoreError(err.code === 'encryption_unavailable' ? 'encryption_unavailable' : 'decrypt_failed', err.message);
471
+ }
472
+ return new core.SSHKeyStoreError('decrypt_failed', 'Не удалось расшифровать секрет');
473
+ }
474
+ /** Порт хранилища SSH-ключей поверх `ssh_keys`/`ssh_key_agents` (секреты AES-256-GCM). */
475
+ class PostgresSSHKeyRepository {
476
+ _deps;
477
+ _masterKeyPromise;
478
+ constructor(_deps) {
479
+ this._deps = _deps;
480
+ }
481
+ _db() {
482
+ return this._deps.connection;
483
+ }
484
+ async _masterKey() {
485
+ const core = await loadCore();
486
+ if (!this._masterKeyPromise) {
487
+ this._masterKeyPromise = core
488
+ .resolveMasterKey({ dataDir: this._deps.dataDir, secretKey: this._deps.secretKey, env: this._deps.env })
489
+ .then((result) => result.key)
490
+ .catch((err) => {
491
+ this._masterKeyPromise = undefined;
492
+ throw mapCryptoError(err, core);
493
+ });
494
+ }
495
+ return { core, key: await this._masterKeyPromise };
496
+ }
497
+ async _agentIds(keyId) {
498
+ const rows = await this._db().query('SELECT agent_id FROM ssh_key_agents WHERE key_id = $1 ORDER BY agent_id', [keyId]);
499
+ return rows.map((row) => String(row.agent_id));
500
+ }
501
+ async _getRow(id) {
502
+ const rows = await this._db().query('SELECT * FROM ssh_keys WHERE id = $1', [id]);
503
+ return rows[0] ?? null;
504
+ }
505
+ async list() {
506
+ const rows = await this._db().query(`SELECT k.*, COALESCE(array_agg(a.agent_id ORDER BY a.agent_id)
507
+ FILTER (WHERE a.agent_id IS NOT NULL), '{}') AS agent_ids
508
+ FROM ssh_keys k
509
+ LEFT JOIN ssh_key_agents a ON a.key_id = k.id
510
+ GROUP BY k.id
511
+ ORDER BY k.name ASC`);
512
+ return rows.map((row) => sshKeyToMeta(row, asStringArray(row.agent_ids)));
513
+ }
514
+ async listRaw() {
515
+ const rows = await this._db().query(`SELECT k.*, COALESCE(array_agg(a.agent_id ORDER BY a.agent_id)
516
+ FILTER (WHERE a.agent_id IS NOT NULL), '{}') AS agent_ids
517
+ FROM ssh_keys k
518
+ LEFT JOIN ssh_key_agents a ON a.key_id = k.id
519
+ GROUP BY k.id
520
+ ORDER BY k.name ASC`);
521
+ return rows.map((row) => {
522
+ const record = {
523
+ id: row.id,
524
+ name: row.name,
525
+ type: row.type ?? 'user',
526
+ privateKey: bufferToToken(row.private_enc),
527
+ agentIds: asStringArray(row.agent_ids),
528
+ createdAt: toISO(row.created_at),
529
+ };
530
+ const updatedAt = toISOOrUndefined(row.updated_at);
531
+ if (updatedAt !== undefined)
532
+ record.updatedAt = updatedAt;
533
+ if (row.passphrase_enc !== null)
534
+ record.passphrase = bufferToToken(row.passphrase_enc);
535
+ return record;
536
+ });
537
+ }
538
+ async listForAgent(agentId) {
539
+ const rows = await this._db().query(`SELECT k.*, COALESCE(array_agg(a.agent_id ORDER BY a.agent_id)
540
+ FILTER (WHERE a.agent_id IS NOT NULL), '{}') AS agent_ids
541
+ FROM ssh_keys k
542
+ JOIN ssh_key_agents a ON a.key_id = k.id
543
+ WHERE EXISTS (SELECT 1 FROM ssh_key_agents x WHERE x.key_id = k.id AND x.agent_id = $1)
544
+ GROUP BY k.id
545
+ ORDER BY k.name ASC`, [agentId]);
546
+ return rows.map((row) => sshKeyToMeta(row, asStringArray(row.agent_ids)));
547
+ }
548
+ async get(id) {
549
+ const row = await this._getRow(id);
550
+ if (!row)
551
+ return null;
552
+ return sshKeyToMeta(row, await this._agentIds(id));
553
+ }
554
+ async _assertNameUnique(name, excludeId) {
555
+ const rows = await this._db().query('SELECT id FROM ssh_keys WHERE lower(name) = lower($1) AND ($2::text IS NULL OR id <> $2) LIMIT 1', [name, excludeId ?? null]);
556
+ if (rows.length > 0) {
557
+ const { SSHKeyStoreError } = await loadCore();
558
+ throw new SSHKeyStoreError('name_exists', `SSH-ключ "${name}" уже существует`);
559
+ }
560
+ }
561
+ async create(input) {
562
+ if (!input.privateKey || input.privateKey.trim() === '') {
563
+ const { SSHKeyStoreError } = await loadCore();
564
+ throw new SSHKeyStoreError('invalid', 'Приватный ключ не может быть пустым');
565
+ }
566
+ await this._assertNameUnique(input.name);
567
+ const { core, key } = await this._masterKey();
568
+ const now = nowISO();
569
+ const id = generateId();
570
+ const agentIds = input.agentIds ? [...input.agentIds] : [];
571
+ const privateEnc = core.encryptSecret(input.privateKey, key);
572
+ const passphraseEnc = input.passphrase === undefined ? null : core.encryptSecret(input.passphrase, key);
573
+ await this._deps.connection.withTransaction(async (tx) => {
574
+ await tx.query(`INSERT INTO ssh_keys (id, name, type, private_enc, passphrase_enc, created_at, updated_at)
575
+ VALUES ($1,$2,$3,$4::bytea,$5::bytea,$6,$7)`, [id, input.name, input.type ?? 'user', privateEnc, passphraseEnc, now, now]);
576
+ for (const agentId of agentIds) {
577
+ await tx.query('INSERT INTO ssh_key_agents (key_id, agent_id) VALUES ($1,$2) ON CONFLICT DO NOTHING', [id, agentId]);
578
+ }
579
+ });
580
+ return sshKeyToMeta({ id, name: input.name, type: input.type ?? 'user', private_enc: privateEnc, passphrase_enc: passphraseEnc, created_at: now, updated_at: now }, agentIds);
581
+ }
582
+ async update(id, patch) {
583
+ const existing = await this._getRow(id);
584
+ if (!existing)
585
+ return null;
586
+ const { core, key } = await this._masterKey();
587
+ if (patch.name !== undefined && patch.name.toLowerCase() !== existing.name.toLowerCase()) {
588
+ await this._assertNameUnique(patch.name, id);
589
+ }
590
+ if (patch.privateKey !== undefined && (!patch.privateKey || patch.privateKey.trim() === '')) {
591
+ throw new core.SSHKeyStoreError('invalid', 'Приватный ключ не может быть пустым');
592
+ }
593
+ const nextName = patch.name ?? existing.name;
594
+ const nextType = patch.type ?? existing.type ?? 'user';
595
+ const nextPrivate = patch.privateKey !== undefined ? core.encryptSecret(patch.privateKey, key) : bufferToToken(existing.private_enc);
596
+ const nextPassphrase = patch.passphrase !== undefined
597
+ ? core.encryptSecret(patch.passphrase, key)
598
+ : existing.passphrase_enc === null
599
+ ? null
600
+ : bufferToToken(existing.passphrase_enc);
601
+ const updatedAt = nowISO();
602
+ const agentIds = patch.agentIds !== undefined ? [...patch.agentIds] : await this._agentIds(id);
603
+ await this._deps.connection.withTransaction(async (tx) => {
604
+ await tx.query(`UPDATE ssh_keys
605
+ SET name = $2, type = $3, private_enc = $4::bytea, passphrase_enc = $5::bytea, updated_at = $6
606
+ WHERE id = $1`, [id, nextName, nextType, nextPrivate, nextPassphrase, updatedAt]);
607
+ if (patch.agentIds !== undefined) {
608
+ await tx.query('DELETE FROM ssh_key_agents WHERE key_id = $1', [id]);
609
+ for (const agentId of agentIds) {
610
+ await tx.query('INSERT INTO ssh_key_agents (key_id, agent_id) VALUES ($1,$2) ON CONFLICT DO NOTHING', [id, agentId]);
611
+ }
612
+ }
613
+ });
614
+ return sshKeyToMeta({
615
+ id,
616
+ name: nextName,
617
+ type: nextType,
618
+ private_enc: nextPrivate,
619
+ passphrase_enc: nextPassphrase,
620
+ created_at: existing.created_at,
621
+ updated_at: updatedAt,
622
+ }, agentIds);
623
+ }
624
+ async delete(id) {
625
+ const rows = await this._db().query('DELETE FROM ssh_keys WHERE id = $1 RETURNING id', [id]);
626
+ return rows.length > 0;
627
+ }
628
+ async linkAgent(id, agentId) {
629
+ if (!(await this._getRow(id)))
630
+ return null;
631
+ await this._db().query('INSERT INTO ssh_key_agents (key_id, agent_id) VALUES ($1,$2) ON CONFLICT DO NOTHING', [id, agentId]);
632
+ await this._db().query('UPDATE ssh_keys SET updated_at = $2 WHERE id = $1', [id, nowISO()]);
633
+ return this.get(id);
634
+ }
635
+ async unlinkAgent(id, agentId) {
636
+ if (!(await this._getRow(id)))
637
+ return null;
638
+ await this._db().query('DELETE FROM ssh_key_agents WHERE key_id = $1 AND agent_id = $2', [id, agentId]);
639
+ await this._db().query('UPDATE ssh_keys SET updated_at = $2 WHERE id = $1', [id, nowISO()]);
640
+ return this.get(id);
641
+ }
642
+ async reveal(id) {
643
+ const row = await this._getRow(id);
644
+ if (!row)
645
+ return null;
646
+ const { core, key } = await this._masterKey();
647
+ try {
648
+ const privateKey = core.decryptSecret(bufferToToken(row.private_enc), key);
649
+ if (row.passphrase_enc === null)
650
+ return { privateKey };
651
+ return { privateKey, passphrase: core.decryptSecret(bufferToToken(row.passphrase_enc), key) };
652
+ }
653
+ catch (err) {
654
+ throw mapCryptoError(err, core);
655
+ }
656
+ }
657
+ async rotateMasterKey(oldKey, newKey, opts = {}) {
658
+ const core = await loadCore();
659
+ if (oldKey.length !== core.crypto.MASTER_KEY_LENGTH || newKey.length !== core.crypto.MASTER_KEY_LENGTH) {
660
+ throw new core.SSHKeyStoreError('invalid', 'Мастер-ключ должен быть 32 байта');
661
+ }
662
+ const rows = await this._db().query('SELECT * FROM ssh_keys ORDER BY name ASC');
663
+ const failures = new Set();
664
+ const planned = [];
665
+ for (const row of rows) {
666
+ const privateKey = bufferToToken(row.private_enc);
667
+ const passphrase = row.passphrase_enc === null ? null : bufferToToken(row.passphrase_enc);
668
+ const plan = planRotation(core, privateKey, passphrase, oldKey, newKey);
669
+ if (!plan) {
670
+ failures.add(row.id);
671
+ continue;
672
+ }
673
+ planned.push({ row, privateKey: plan.privateKey, passphrase: plan.passphrase, kind: plan.kind });
674
+ }
675
+ if (failures.size > 0) {
676
+ throw new core.SSHKeyStoreError('preflight_failed', `Не удалось расшифровать SSH-ключи (ни старым, ни новым ключом): ${[...failures].sort().join(', ')}`);
677
+ }
678
+ let rotated = 0;
679
+ let upgraded = 0;
680
+ let skipped = 0;
681
+ const ids = [];
682
+ for (const item of planned) {
683
+ if (item.kind === 'rotated') {
684
+ rotated += 1;
685
+ ids.push(item.row.id);
686
+ }
687
+ else if (item.kind === 'upgraded') {
688
+ upgraded += 1;
689
+ ids.push(item.row.id);
690
+ }
691
+ else {
692
+ skipped += 1;
693
+ }
694
+ if (item.kind !== 'skipped' && !opts.dryRun) {
695
+ await this._db().query('UPDATE ssh_keys SET private_enc = $2::bytea, passphrase_enc = $3::bytea WHERE id = $1', [item.row.id, item.privateKey, item.passphrase]);
696
+ }
697
+ }
698
+ return { total: rows.length, rotated, upgraded, skipped, ids };
699
+ }
700
+ }
701
+ /** Планирует ротацию полей одной записи (plaintext → upgraded, старый шифр → rotated). */
702
+ function planRotation(core, privateKey, passphrase, oldKey, newKey) {
703
+ let kind = 'skipped';
704
+ const rotateToken = (token) => {
705
+ if (!core.isEncrypted(token)) {
706
+ kind = 'upgraded';
707
+ return core.encryptSecret(token, newKey);
708
+ }
709
+ try {
710
+ core.decryptSecret(token, newKey);
711
+ return token;
712
+ }
713
+ catch {
714
+ // не расшифровывается новым — пробуем старым
715
+ }
716
+ try {
717
+ const plaintext = core.decryptSecret(token, oldKey);
718
+ kind = 'rotated';
719
+ return core.encryptSecret(plaintext, newKey);
720
+ }
721
+ catch {
722
+ return null;
723
+ }
724
+ };
725
+ const nextPrivate = rotateToken(privateKey);
726
+ if (nextPrivate === null)
727
+ return null;
728
+ let nextPassphrase = passphrase;
729
+ if (passphrase !== null) {
730
+ nextPassphrase = rotateToken(passphrase);
731
+ if (nextPassphrase === null)
732
+ return null;
733
+ }
734
+ return { privateKey: nextPrivate, passphrase: nextPassphrase, kind };
735
+ }
736
+ function mcpRowToEntry(row) {
737
+ return {
738
+ schemaVersion: row.schema_version ?? MCP_REGISTRY_SCHEMA_VERSION,
739
+ id: row.id,
740
+ name: row.name,
741
+ config: row.config,
742
+ origin: row.origin,
743
+ author: row.author ?? null,
744
+ trust: row.trust ?? 'community',
745
+ enabled: row.enabled !== false,
746
+ enabledByDefault: row.enabled_by_default === true,
747
+ createdAt: toISO(row.created_at),
748
+ updatedAt: toISO(row.updated_at),
749
+ };
750
+ }
751
+ /** Порт реестра MCP-серверов поверх таблицы `mcp_registry`. */
752
+ class PostgresMcpRegistryRepository {
753
+ _deps;
754
+ constructor(_deps) {
755
+ this._deps = _deps;
756
+ }
757
+ _db() {
758
+ return this._deps.connection;
759
+ }
760
+ async list() {
761
+ const rows = await this._db().query('SELECT * FROM mcp_registry ORDER BY name ASC');
762
+ return rows.map(mcpRowToEntry);
763
+ }
764
+ async get(id) {
765
+ const rows = await this._db().query('SELECT * FROM mcp_registry WHERE id = $1', [id]);
766
+ const row = rows[0];
767
+ return row ? mcpRowToEntry(row) : null;
768
+ }
769
+ async getByName(name) {
770
+ const rows = await this._db().query('SELECT * FROM mcp_registry WHERE name = $1', [name]);
771
+ const row = rows[0];
772
+ return row ? mcpRowToEntry(row) : null;
773
+ }
774
+ async add(input) {
775
+ const duplicate = await this._db().query('SELECT id FROM mcp_registry WHERE name = $1 LIMIT 1', [input.name]);
776
+ if (duplicate.length > 0) {
777
+ throw new Error(`MCP-сервер "${input.name}" уже существует в реестре`);
778
+ }
779
+ const now = nowISO();
780
+ const entry = {
781
+ schemaVersion: MCP_REGISTRY_SCHEMA_VERSION,
782
+ id: input.id ?? generateId(),
783
+ name: input.name,
784
+ config: input.config,
785
+ origin: input.origin,
786
+ author: input.author ?? null,
787
+ trust: input.trust ?? (input.origin === 'instance' ? 'builtin' : 'community'),
788
+ enabled: input.enabled ?? true,
789
+ enabledByDefault: input.enabledByDefault ?? input.config.enabledByDefault ?? false,
790
+ createdAt: now,
791
+ updatedAt: now,
792
+ };
793
+ try {
794
+ await this._insert(entry);
795
+ }
796
+ catch (err) {
797
+ if (err instanceof PostgresUniqueViolationError) {
798
+ throw new Error(`MCP-сервер "${input.name}" уже существует в реестре`);
799
+ }
800
+ throw err;
801
+ }
802
+ return entry;
803
+ }
804
+ async _insert(entry) {
805
+ await this._db().query(`INSERT INTO mcp_registry
806
+ (id, schema_version, name, config, origin, author, trust, enabled, enabled_by_default, created_at, updated_at)
807
+ VALUES ($1,$2,$3,$4::jsonb,$5,$6::jsonb,$7::jsonb,$8,$9,$10,$11)`, [
808
+ entry.id,
809
+ entry.schemaVersion,
810
+ entry.name,
811
+ jsonParam(entry.config),
812
+ entry.origin,
813
+ entry.author === null ? null : jsonParam(entry.author),
814
+ jsonParam(entry.trust),
815
+ entry.enabled,
816
+ entry.enabledByDefault,
817
+ entry.createdAt,
818
+ entry.updatedAt,
819
+ ]);
820
+ }
821
+ async update(id, patch) {
822
+ const rows = await this._db().query('SELECT * FROM mcp_registry WHERE id = $1', [id]);
823
+ const current = rows[0];
824
+ if (!current)
825
+ return null;
826
+ const entry = mcpRowToEntry(current);
827
+ if (patch.name && patch.name !== entry.name) {
828
+ const dup = await this._db().query('SELECT id FROM mcp_registry WHERE name = $1 AND id <> $2 LIMIT 1', [patch.name, id]);
829
+ if (dup.length > 0)
830
+ throw new Error(`MCP-сервер "${patch.name}" уже существует в реестре`);
831
+ }
832
+ const updated = {
833
+ ...entry,
834
+ name: patch.name ?? entry.name,
835
+ config: patch.config ?? entry.config,
836
+ origin: patch.origin ?? entry.origin,
837
+ trust: patch.trust ?? entry.trust,
838
+ enabled: patch.enabled ?? entry.enabled,
839
+ enabledByDefault: patch.enabledByDefault ?? entry.enabledByDefault,
840
+ schemaVersion: MCP_REGISTRY_SCHEMA_VERSION,
841
+ updatedAt: nowISO(),
842
+ };
843
+ try {
844
+ await this._db().query(`UPDATE mcp_registry
845
+ SET name = $2, config = $3::jsonb, origin = $4, trust = $5::jsonb,
846
+ enabled = $6, enabled_by_default = $7, schema_version = $8, updated_at = $9
847
+ WHERE id = $1`, [
848
+ id,
849
+ updated.name,
850
+ jsonParam(updated.config),
851
+ updated.origin,
852
+ jsonParam(updated.trust),
853
+ updated.enabled,
854
+ updated.enabledByDefault,
855
+ updated.schemaVersion,
856
+ updated.updatedAt,
857
+ ]);
858
+ }
859
+ catch (err) {
860
+ if (err instanceof PostgresUniqueViolationError) {
861
+ throw new Error(`MCP-сервер "${updated.name}" уже существует в реестре`);
862
+ }
863
+ throw err;
864
+ }
865
+ return updated;
866
+ }
867
+ async remove(id) {
868
+ const rows = await this._db().query('DELETE FROM mcp_registry WHERE id = $1 RETURNING id', [id]);
869
+ return rows.length > 0;
870
+ }
871
+ async seedFromConfig(servers) {
872
+ const existing = new Set((await this._db().query('SELECT name FROM mcp_registry')).map((row) => String(row.name)));
873
+ let added = 0;
874
+ for (const [name, config] of Object.entries(servers)) {
875
+ if (existing.has(name))
876
+ continue;
877
+ await this._insert({
878
+ schemaVersion: MCP_REGISTRY_SCHEMA_VERSION,
879
+ id: generateId(),
880
+ name,
881
+ config,
882
+ origin: 'instance',
883
+ author: null,
884
+ trust: 'builtin',
885
+ enabled: config.enabled !== false,
886
+ enabledByDefault: config.enabledByDefault ?? false,
887
+ createdAt: nowISO(),
888
+ updatedAt: nowISO(),
889
+ });
890
+ added += 1;
891
+ }
892
+ return added;
893
+ }
894
+ async toServerConfigMap() {
895
+ const map = {};
896
+ for (const entry of await this.list())
897
+ map[entry.name] = entry.config;
898
+ return map;
899
+ }
900
+ async toOriginMap() {
901
+ const map = {};
902
+ for (const entry of await this.list())
903
+ map[entry.name] = entry.origin;
904
+ return map;
905
+ }
906
+ async toTrustMap() {
907
+ const map = {};
908
+ for (const entry of await this.list())
909
+ map[entry.name] = entry.trust;
910
+ return map;
911
+ }
912
+ async toAuthorMap() {
913
+ const map = {};
914
+ for (const entry of await this.list())
915
+ if (entry.author)
916
+ map[entry.name] = entry.author;
917
+ return map;
918
+ }
919
+ async toDefaultServers() {
920
+ return (await this.list())
921
+ .filter((entry) => entry.origin === 'instance' && entry.enabledByDefault)
922
+ .map((entry) => entry.name);
923
+ }
924
+ async toManagerMaps() {
925
+ const servers = {};
926
+ const origins = {};
927
+ const trusts = {};
928
+ const authors = {};
929
+ const systemEnabled = {};
930
+ const defaults = [];
931
+ for (const entry of await this.list()) {
932
+ servers[entry.name] = entry.config;
933
+ origins[entry.name] = entry.origin;
934
+ trusts[entry.name] = entry.trust;
935
+ systemEnabled[entry.name] = entry.enabled !== false;
936
+ if (entry.author)
937
+ authors[entry.name] = entry.author;
938
+ if (entry.origin === 'instance' && entry.enabledByDefault)
939
+ defaults.push(entry.name);
940
+ }
941
+ return { servers, origins, trusts, authors, systemEnabled, defaults };
942
+ }
943
+ }
944
+ function assertBundleName(name) {
945
+ if (!name || name.length > SKILL_NAME_MAX || !SKILL_NAME_REGEX.test(name)) {
946
+ throw new Error(`Недопустимое имя bundle: ${name}`);
947
+ }
948
+ }
949
+ function bundleRowToBundle(row) {
950
+ const bundle = {
951
+ name: row.name,
952
+ description: row.description,
953
+ skills: asStringArray(row.skills),
954
+ };
955
+ if (row.instruction !== null)
956
+ bundle.instruction = row.instruction;
957
+ return bundle;
958
+ }
959
+ /** Порт instance-хранилища bundles поверх таблицы `skill_bundles`. */
960
+ class PostgresSkillBundleRepository {
961
+ _deps;
962
+ constructor(_deps) {
963
+ this._deps = _deps;
964
+ }
965
+ _db() {
966
+ return this._deps.connection;
967
+ }
968
+ async exists(name) {
969
+ const rows = await this._db().query('SELECT 1 AS ok FROM skill_bundles WHERE name = $1 LIMIT 1', [name]);
970
+ return rows.length > 0;
971
+ }
972
+ async get(name) {
973
+ const rows = await this._db().query('SELECT * FROM skill_bundles WHERE name = $1', [name]);
974
+ const row = rows[0];
975
+ return row ? bundleRowToBundle(row) : undefined;
976
+ }
977
+ async list() {
978
+ const rows = await this._db().query('SELECT * FROM skill_bundles ORDER BY name ASC');
979
+ return rows.map(bundleRowToBundle);
980
+ }
981
+ async set(bundle) {
982
+ assertBundleName(bundle.name);
983
+ await this._db().query(`INSERT INTO skill_bundles (name, description, skills, instruction)
984
+ VALUES ($1,$2,$3::jsonb,$4)
985
+ ON CONFLICT (name) DO UPDATE
986
+ SET description = EXCLUDED.description,
987
+ skills = EXCLUDED.skills,
988
+ instruction = EXCLUDED.instruction`, [bundle.name, bundle.description, jsonParam(bundle.skills), bundle.instruction ?? null]);
989
+ }
990
+ async remove(name) {
991
+ assertBundleName(name);
992
+ const rows = await this._db().query('DELETE FROM skill_bundles WHERE name = $1 RETURNING name', [name]);
993
+ return rows.length > 0;
994
+ }
995
+ }
996
+ function maintenanceRowToEntry(row) {
997
+ const entry = {
998
+ id: row.id,
999
+ ts: toISO(row.ts),
1000
+ op: row.op,
1001
+ status: row.status,
1002
+ };
1003
+ if (row.actor !== null)
1004
+ entry.actor = row.actor;
1005
+ if (row.version !== null)
1006
+ entry.version = row.version;
1007
+ if (row.details !== null && row.details !== undefined)
1008
+ entry.details = row.details;
1009
+ if (row.error !== null)
1010
+ entry.error = row.error;
1011
+ return entry;
1012
+ }
1013
+ /** Порт append-only аудит-журнала обслуживания поверх таблицы `maintenance_audit`. */
1014
+ class PostgresMaintenanceAuditRepository {
1015
+ _deps;
1016
+ constructor(_deps) {
1017
+ this._deps = _deps;
1018
+ }
1019
+ _db() {
1020
+ return this._deps.connection;
1021
+ }
1022
+ async append(entry) {
1023
+ await this._db().query(`INSERT INTO maintenance_audit (id, ts, op, status, actor, version, details, error)
1024
+ VALUES ($1,$2,$3,$4,$5,$6,$7::jsonb,$8)`, [
1025
+ entry.id,
1026
+ entry.ts,
1027
+ entry.op,
1028
+ entry.status,
1029
+ entry.actor ?? null,
1030
+ entry.version ?? null,
1031
+ entry.details !== undefined ? jsonParam(entry.details) : null,
1032
+ entry.error ?? null,
1033
+ ]);
1034
+ }
1035
+ async list(opts = {}) {
1036
+ const params = [];
1037
+ let where = '';
1038
+ if (opts.op !== undefined) {
1039
+ params.push(opts.op);
1040
+ where = `WHERE op = $${params.length}`;
1041
+ }
1042
+ let limit = '';
1043
+ const { limit: requested } = opts;
1044
+ if (requested !== undefined && Number.isFinite(requested) && requested > 0) {
1045
+ params.push(Math.floor(requested));
1046
+ limit = `LIMIT $${params.length}::int`;
1047
+ }
1048
+ const rows = await this._db().query(`SELECT * FROM maintenance_audit ${where} ORDER BY seq DESC ${limit}`, params);
1049
+ return rows.map(maintenanceRowToEntry);
1050
+ }
1051
+ async clear() {
1052
+ const rows = await this._db().query('WITH deleted AS (DELETE FROM maintenance_audit RETURNING 1) SELECT count(*)::int AS n FROM deleted');
1053
+ const value = rows[0]?.n;
1054
+ return typeof value === 'number' ? value : 0;
1055
+ }
1056
+ }
1057
+ // ────────────────────────────────────────────────────────────────────────────
1058
+ // secretPatterns (ADR-036) — синхронный кэш-фасад
1059
+ // ────────────────────────────────────────────────────────────────────────────
1060
+ const SECRET_PATTERNS_KEY = 'storage.override.secret_patterns';
1061
+ /** Валиден ли паттерн (непустой `type`, компилируемый `regex`) — паритет с core. */
1062
+ function isValidPattern(value) {
1063
+ if (typeof value !== 'object' || value === null)
1064
+ return false;
1065
+ const { type, regex } = value;
1066
+ if (typeof type !== 'string' || type.trim() === '')
1067
+ return false;
1068
+ if (typeof regex !== 'string')
1069
+ return false;
1070
+ try {
1071
+ new RegExp(regex);
1072
+ return true;
1073
+ }
1074
+ catch {
1075
+ return false;
1076
+ }
1077
+ }
1078
+ /**
1079
+ * Дефолтные паттерны в сериализуемом виде (копия инъектированного набора core,
1080
+ * `DEFAULT_PATTERNS`). Всегда свежая копия — вызывающий не мутирует инъекцию.
1081
+ */
1082
+ function defaultSecretPatterns(deps) {
1083
+ return deps.coreSync.secretPatterns.map((pattern) => ({ ...pattern }));
1084
+ }
1085
+ /** Порт паттернов детекции секретов (системный дефолт + DB-override, sync-геттеры). */
1086
+ class PostgresSecretPatternRepository {
1087
+ _deps;
1088
+ _override = null;
1089
+ _warmed = false;
1090
+ constructor(_deps) {
1091
+ this._deps = _deps;
1092
+ }
1093
+ /** Best-effort прогрев override из `settings` (стартует при сборке контекста). */
1094
+ async warm() {
1095
+ if (this._warmed)
1096
+ return;
1097
+ const value = await loadSetting(this._deps.connection, SECRET_PATTERNS_KEY);
1098
+ // Гонка warm ↔ мутация: пока ждали БД, мутация уже прогрела/записала кэш
1099
+ // (`_warmed = true`) — не перетираем его устаревшим чтением.
1100
+ if (this._warmed)
1101
+ return;
1102
+ if (Array.isArray(value) && value.every(isValidPattern)) {
1103
+ this._override = value.map((pattern) => ({ type: pattern.type, regex: pattern.regex }));
1104
+ }
1105
+ this._warmed = true;
1106
+ }
1107
+ hasOverride() {
1108
+ return this._override !== null;
1109
+ }
1110
+ getDefaultPatterns() {
1111
+ return defaultSecretPatterns(this._deps);
1112
+ }
1113
+ getPatterns() {
1114
+ if (this._override === null)
1115
+ return this.getDefaultPatterns();
1116
+ return this._override.map((pattern) => ({ ...pattern }));
1117
+ }
1118
+ getEffectivePatterns() {
1119
+ return this.getPatterns();
1120
+ }
1121
+ async savePatterns(patterns) {
1122
+ if (!Array.isArray(patterns) || !patterns.every(isValidPattern))
1123
+ return false;
1124
+ const normalized = patterns.map((pattern) => ({ type: pattern.type, regex: pattern.regex }));
1125
+ await saveSetting(this._deps.connection, SECRET_PATTERNS_KEY, normalized);
1126
+ this._override = normalized;
1127
+ this._warmed = true;
1128
+ return true;
1129
+ }
1130
+ async reset() {
1131
+ if (this._override === null)
1132
+ return false;
1133
+ await deleteSetting(this._deps.connection, SECRET_PATTERNS_KEY);
1134
+ this._override = null;
1135
+ this._warmed = true;
1136
+ return true;
1137
+ }
1138
+ getRawPatterns() {
1139
+ return {
1140
+ isOverridden: this.hasOverride(),
1141
+ patterns: this.getPatterns(),
1142
+ defaultPatterns: this.getDefaultPatterns(),
1143
+ };
1144
+ }
1145
+ }
1146
+ // ────────────────────────────────────────────────────────────────────────────
1147
+ // protectedPaths — синхронный кэш-фасад
1148
+ // ────────────────────────────────────────────────────────────────────────────
1149
+ const PROTECTED_PATHS_KEY = 'storage.override.protected_paths';
1150
+ const POLICY_LIST_KEYS = ['deniedPaths', 'deniedPrefixes', 'approvalPaths', 'deniedCommandPrefixes'];
1151
+ function isStringArray(value) {
1152
+ return Array.isArray(value) && value.every((item) => typeof item === 'string');
1153
+ }
1154
+ function clonePolicy(policy) {
1155
+ const clone = {
1156
+ deniedPaths: [...policy.deniedPaths],
1157
+ deniedPrefixes: [...policy.deniedPrefixes],
1158
+ approvalPaths: [...policy.approvalPaths],
1159
+ deniedCommandPrefixes: [...policy.deniedCommandPrefixes],
1160
+ };
1161
+ if (policy.dataDir !== undefined)
1162
+ clone.dataDir = policy.dataDir;
1163
+ return clone;
1164
+ }
1165
+ function applyCascade(base, add, remove) {
1166
+ const removed = new Set(remove);
1167
+ const kept = base.filter((item) => !removed.has(item));
1168
+ const added = new Set(kept);
1169
+ for (const item of add)
1170
+ if (!added.has(item))
1171
+ kept.push(item);
1172
+ return kept;
1173
+ }
1174
+ function applyOverride(base, override) {
1175
+ const result = {
1176
+ deniedPaths: [],
1177
+ deniedPrefixes: [],
1178
+ approvalPaths: [],
1179
+ deniedCommandPrefixes: [],
1180
+ };
1181
+ for (const key of POLICY_LIST_KEYS) {
1182
+ result[key] = applyCascade(base[key] ?? [], override.add[key] ?? [], override.remove[key] ?? []);
1183
+ }
1184
+ return result;
1185
+ }
1186
+ function emptyOverride() {
1187
+ return { version: 1, add: {}, remove: {} };
1188
+ }
1189
+ function normalizeOverride(raw) {
1190
+ const add = raw.add ?? {};
1191
+ const remove = raw.remove ?? {};
1192
+ const override = emptyOverride();
1193
+ override.version = typeof raw.version === 'number' ? raw.version : 1;
1194
+ for (const key of POLICY_LIST_KEYS) {
1195
+ override.add[key] = isStringArray(add[key]) ? [...add[key]] : [];
1196
+ override.remove[key] = isStringArray(remove[key]) ? [...remove[key]] : [];
1197
+ }
1198
+ return override;
1199
+ }
1200
+ /** Порт защищённых путей (системный base + DB-override, sync-геттеры). */
1201
+ class PostgresProtectedPathsRepository {
1202
+ _deps;
1203
+ _base;
1204
+ _override = null;
1205
+ _warmed = false;
1206
+ constructor(_deps) {
1207
+ this._deps = _deps;
1208
+ }
1209
+ /** Best-effort прогрев override из `settings`. */
1210
+ async warm() {
1211
+ if (this._warmed)
1212
+ return;
1213
+ const value = await loadSetting(this._deps.connection, PROTECTED_PATHS_KEY);
1214
+ // См. `secretPatterns.warm`: не перетираем кэш после конкурентной мутации.
1215
+ if (this._warmed)
1216
+ return;
1217
+ if (typeof value === 'object' && value !== null) {
1218
+ this._override = normalizeOverride(value);
1219
+ }
1220
+ this._warmed = true;
1221
+ }
1222
+ /** Системный base (definitions/protected-paths.json); sync, всегда свежая копия. */
1223
+ _basePolicy() {
1224
+ if (!this._base) {
1225
+ this._base = this._deps.coreSync.protectedPathsBase;
1226
+ }
1227
+ return this._base;
1228
+ }
1229
+ _effective() {
1230
+ const base = this._basePolicy();
1231
+ const merged = this._override ? applyOverride(base, this._override) : base;
1232
+ const dynamic = [join(this._deps.dataDir, 'secrets'), join(this._deps.dataDir, 'security')];
1233
+ const seen = new Set(merged.deniedPrefixes.map((prefix) => normalize(prefix)));
1234
+ const deniedPrefixes = [...merged.deniedPrefixes];
1235
+ for (const entry of dynamic) {
1236
+ if (!seen.has(normalize(entry))) {
1237
+ seen.add(normalize(entry));
1238
+ deniedPrefixes.push(entry);
1239
+ }
1240
+ }
1241
+ return { ...merged, deniedPrefixes, dataDir: this._deps.dataDir };
1242
+ }
1243
+ hasOverride() {
1244
+ return this._override !== null;
1245
+ }
1246
+ getBase() {
1247
+ return clonePolicy(this._basePolicy());
1248
+ }
1249
+ getPolicy() {
1250
+ return this._effective();
1251
+ }
1252
+ getEffective() {
1253
+ return this._effective();
1254
+ }
1255
+ getRaw() {
1256
+ const policy = { ...this.getPolicy() };
1257
+ delete policy.dataDir;
1258
+ const base = this.getBase();
1259
+ return { isOverridden: this.hasOverride(), policy, base, defaultBase: base };
1260
+ }
1261
+ getOverride() {
1262
+ return this._override ? normalizeOverride(this._override) : null;
1263
+ }
1264
+ async savePolicy(effective) {
1265
+ if (!POLICY_LIST_KEYS.every((key) => isStringArray(effective[key] ?? [])))
1266
+ return false;
1267
+ const base = this._basePolicy();
1268
+ const override = emptyOverride();
1269
+ for (const key of POLICY_LIST_KEYS) {
1270
+ const baseArr = base[key] ?? [];
1271
+ const effArr = effective[key] ?? [];
1272
+ const effSet = new Set(effArr);
1273
+ const baseSet = new Set(baseArr);
1274
+ override.add[key] = effArr.filter((item) => !baseSet.has(item));
1275
+ override.remove[key] = baseArr.filter((item) => !effSet.has(item));
1276
+ }
1277
+ await saveSetting(this._deps.connection, PROTECTED_PATHS_KEY, override);
1278
+ this._override = override;
1279
+ this._warmed = true;
1280
+ return true;
1281
+ }
1282
+ async saveRawOverride(raw) {
1283
+ const override = normalizeOverride(raw);
1284
+ await saveSetting(this._deps.connection, PROTECTED_PATHS_KEY, override);
1285
+ this._override = override;
1286
+ this._warmed = true;
1287
+ return true;
1288
+ }
1289
+ async reset() {
1290
+ if (this._override === null)
1291
+ return false;
1292
+ await deleteSetting(this._deps.connection, PROTECTED_PATHS_KEY);
1293
+ this._override = null;
1294
+ this._warmed = true;
1295
+ return true;
1296
+ }
1297
+ }
1298
+ // ────────────────────────────────────────────────────────────────────────────
1299
+ // dictionaries (ADR-034/ADR-035) — синхронный кэш-фасад
1300
+ // ────────────────────────────────────────────────────────────────────────────
1301
+ const DICTIONARIES_KEY = 'storage.override.dictionaries';
1302
+ function emptyDictionariesOverride() {
1303
+ return { entries: {}, codingTools: null };
1304
+ }
1305
+ function dedupe(values) {
1306
+ const seen = new Set();
1307
+ const out = [];
1308
+ for (const value of values) {
1309
+ if (seen.has(value))
1310
+ continue;
1311
+ seen.add(value);
1312
+ out.push(value);
1313
+ }
1314
+ return out;
1315
+ }
1316
+ /** Строгий парсер YAML-содержимого словаря (`keywords:`/`tools:`), как в core/memory. */
1317
+ function parseDictionaryContent(raw) {
1318
+ const keywords = [];
1319
+ const tools = [];
1320
+ let current = null;
1321
+ let keywordsSeen = false;
1322
+ let toolsSeen = false;
1323
+ const lines = raw.split('\n');
1324
+ for (let i = 0; i < lines.length; i += 1) {
1325
+ const trimmed = (lines[i] ?? '').trim();
1326
+ if (!trimmed || trimmed.startsWith('#'))
1327
+ continue;
1328
+ if (trimmed === 'keywords:' || trimmed === 'tools:') {
1329
+ current = trimmed === 'keywords:' ? 'keywords' : 'tools';
1330
+ if (current === 'keywords')
1331
+ keywordsSeen = true;
1332
+ else
1333
+ toolsSeen = true;
1334
+ continue;
1335
+ }
1336
+ if (trimmed.startsWith('-')) {
1337
+ if (!current)
1338
+ throw new Error(`Строка ${i + 1}: элемент списка вне keywords/tools`);
1339
+ let value = trimmed.startsWith('- ') ? trimmed.slice(2) : trimmed.slice(1);
1340
+ value = value.trim().replace(/^["']|["']$/g, '');
1341
+ if (!value)
1342
+ throw new Error(`Строка ${i + 1}: пустое значение списка`);
1343
+ if (current === 'keywords')
1344
+ keywords.push(value.toLowerCase());
1345
+ else
1346
+ tools.push(value);
1347
+ continue;
1348
+ }
1349
+ throw new Error(`Строка ${i + 1}: некорректный YAML — ${trimmed}`);
1350
+ }
1351
+ if (!keywordsSeen)
1352
+ throw new Error('YAML: отсутствует ключ keywords');
1353
+ return toolsSeen
1354
+ ? { keywords: dedupe(keywords), tools: dedupe(tools) }
1355
+ : { keywords: dedupe(keywords) };
1356
+ }
1357
+ /**
1358
+ * Порт словарей классификации: системные словари читаются из ассетов core
1359
+ * (синхронно), пользовательский override — из `settings` (sync-кэш + write-through).
1360
+ */
1361
+ class PostgresDictionaryRepository {
1362
+ _deps;
1363
+ _system;
1364
+ _override = emptyDictionariesOverride();
1365
+ _warmed = false;
1366
+ constructor(_deps) {
1367
+ this._deps = _deps;
1368
+ }
1369
+ /** Системный источник словарей, инъектированный core (`DictionaryStore`). */
1370
+ _systemStore() {
1371
+ if (!this._system) {
1372
+ this._system = this._deps.coreSync.systemDictionaries;
1373
+ }
1374
+ return this._system;
1375
+ }
1376
+ /** Best-effort прогрев override из `settings`. */
1377
+ async warm() {
1378
+ if (this._warmed)
1379
+ return;
1380
+ const value = await loadSetting(this._deps.connection, DICTIONARIES_KEY);
1381
+ // См. `secretPatterns.warm`: не перетираем кэш после конкурентной мутации.
1382
+ if (this._warmed)
1383
+ return;
1384
+ if (typeof value === 'object' && value !== null) {
1385
+ const parsed = value;
1386
+ const entries = {};
1387
+ if (parsed.entries && typeof parsed.entries === 'object') {
1388
+ for (const [key, data] of Object.entries(parsed.entries)) {
1389
+ if (!data || !isStringArray(data.keywords))
1390
+ continue;
1391
+ entries[key] = {
1392
+ keywords: [...data.keywords],
1393
+ ...(isStringArray(data.tools) ? { tools: [...data.tools] } : {}),
1394
+ };
1395
+ }
1396
+ }
1397
+ this._override = {
1398
+ entries,
1399
+ codingTools: isStringArray(parsed.codingTools) ? [...parsed.codingTools] : null,
1400
+ };
1401
+ }
1402
+ this._warmed = true;
1403
+ }
1404
+ _entry(category, language) {
1405
+ return this._override.entries[`${category}.${language}`];
1406
+ }
1407
+ getKeywords(category, language) {
1408
+ const override = this._entry(category, language);
1409
+ if (override)
1410
+ return [...override.keywords];
1411
+ return this._systemStore().getKeywords(category, language);
1412
+ }
1413
+ getCategorizedKeywords(category, language) {
1414
+ // Override хранит плоские keywords/tools; категоризированные данные — только
1415
+ // системные (известное ограничение: override не участвует в категоризации).
1416
+ return this._systemStore().getCategorizedKeywords(category, language);
1417
+ }
1418
+ getCodingTools() {
1419
+ if (this._override.codingTools !== null)
1420
+ return [...this._override.codingTools];
1421
+ return this._systemStore().getCodingTools();
1422
+ }
1423
+ isKnownCategory(category) {
1424
+ return this._systemStore().isKnownCategory(category);
1425
+ }
1426
+ isValidLanguage(language) {
1427
+ return this._systemStore().isValidLanguage(language);
1428
+ }
1429
+ getDictionary(category, language) {
1430
+ if (!this.isKnownCategory(category) || !this.isValidLanguage(language))
1431
+ return null;
1432
+ const override = this._entry(category, language);
1433
+ if (!override)
1434
+ return this._systemStore().getDictionary(category, language);
1435
+ const dictionary = {
1436
+ category,
1437
+ language,
1438
+ source: 'user',
1439
+ keywords: [...override.keywords],
1440
+ };
1441
+ if (category === 'coding')
1442
+ dictionary.tools = this.getCodingTools();
1443
+ else if (override.tools)
1444
+ dictionary.tools = [...override.tools];
1445
+ return dictionary;
1446
+ }
1447
+ listDictionaries() {
1448
+ return this._systemStore()
1449
+ .listDictionaries()
1450
+ .map((dictionary) => this.getDictionary(dictionary.category, dictionary.language) ?? dictionary);
1451
+ }
1452
+ async saveUserDictionary(category, language, data) {
1453
+ if (!this.isKnownCategory(category) || !this.isValidLanguage(language))
1454
+ return null;
1455
+ this._override.entries[`${category}.${language}`] = {
1456
+ keywords: [...data.keywords],
1457
+ ...(data.tools !== undefined ? { tools: [...data.tools] } : {}),
1458
+ };
1459
+ if (category === 'coding' && data.tools !== undefined) {
1460
+ this._override.codingTools = [...data.tools];
1461
+ }
1462
+ await this._persist();
1463
+ return this.getDictionary(category, language);
1464
+ }
1465
+ async deleteUserDictionary(category, language) {
1466
+ if (!this.isKnownCategory(category) || !this.isValidLanguage(language))
1467
+ return null;
1468
+ delete this._override.entries[`${category}.${language}`];
1469
+ if (category === 'coding')
1470
+ this._override.codingTools = null;
1471
+ await this._persist();
1472
+ return this.getDictionary(category, language);
1473
+ }
1474
+ getContent(category, language) {
1475
+ const override = this._entry(category, language);
1476
+ if (!override)
1477
+ return this._systemStore().getContent(category, language);
1478
+ const lines = ['keywords:'];
1479
+ for (const keyword of override.keywords)
1480
+ lines.push(` - ${keyword}`);
1481
+ if (override.tools !== undefined) {
1482
+ lines.push('tools:');
1483
+ for (const tool of override.tools)
1484
+ lines.push(` - ${tool}`);
1485
+ }
1486
+ return `${lines.join('\n')}\n`;
1487
+ }
1488
+ async saveUserContent(category, language, content) {
1489
+ if (!this.isKnownCategory(category) || !this.isValidLanguage(language))
1490
+ return null;
1491
+ const { DICTIONARY_MAX_KEYWORDS, DICTIONARY_MAX_TOOLS } = await loadCore();
1492
+ const parsed = parseDictionaryContent(content);
1493
+ if (parsed.keywords.length > DICTIONARY_MAX_KEYWORDS) {
1494
+ throw new Error(`keywords: не более ${DICTIONARY_MAX_KEYWORDS} слов`);
1495
+ }
1496
+ if (parsed.tools && parsed.tools.length > DICTIONARY_MAX_TOOLS) {
1497
+ throw new Error(`tools: не более ${DICTIONARY_MAX_TOOLS} элементов`);
1498
+ }
1499
+ return this.saveUserDictionary(category, language, parsed);
1500
+ }
1501
+ async _persist() {
1502
+ await saveSetting(this._deps.connection, DICTIONARIES_KEY, this._override);
1503
+ this._warmed = true;
1504
+ }
1505
+ }
1506
+ // ────────────────────────────────────────────────────────────────────────────
1507
+ // Сборка группы портов
1508
+ // ────────────────────────────────────────────────────────────────────────────
1509
+ /** Собрать порты группы `content`. */
1510
+ export function buildContentPorts(deps) {
1511
+ const secretPatterns = new PostgresSecretPatternRepository(deps);
1512
+ const protectedPaths = new PostgresProtectedPathsRepository(deps);
1513
+ const dictionaries = new PostgresDictionaryRepository(deps);
1514
+ // Best-effort прогрев синхронных кэшей из БД (не блокирует сборку контекста:
1515
+ // фабрика синхронная, а awaited-конструктора у драйвера нет). Мутации
1516
+ // write-through, поэтому кэш консистентен сразу после записи; pre-existing
1517
+ // override появляется в кэше по завершении прогрева (короткое окно старта).
1518
+ // Если схема ещё не инициализирована — прогрев пропускается с одним сообщением.
1519
+ //
1520
+ // Прогрев остаётся fire-and-forget, но если владелец контекста умеет
1521
+ // отслеживать фоновые задачи (`trackBackground`), регистрируем его — тогда
1522
+ // `close()` дождётся завершения прогрева до закрытия пула. Иначе late
1523
+ // warm-запросы уходят в закрытый пул и дают ложные «пул недоступен».
1524
+ const warm = warmContentCaches(deps, { secretPatterns, protectedPaths, dictionaries });
1525
+ if (deps.trackBackground)
1526
+ deps.trackBackground(warm);
1527
+ else
1528
+ void warm;
1529
+ return {
1530
+ serviceKeys: new PostgresServiceKeyRepository(deps),
1531
+ sshKeys: new PostgresSSHKeyRepository(deps),
1532
+ mcpRegistry: new PostgresMcpRegistryRepository(deps),
1533
+ skillBundles: new PostgresSkillBundleRepository(deps),
1534
+ dictionaries,
1535
+ secretPatterns,
1536
+ protectedPaths,
1537
+ maintenanceAudit: new PostgresMaintenanceAuditRepository(deps),
1538
+ };
1539
+ }