@designerbyron/lifecode-rag 0.0.0-stage → 1.0.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/LICENSE +21 -0
- package/README.md +191 -2
- package/bin/lifecode-rag.mjs +449 -0
- package/client.js +2801 -0
- package/cordis.patch.yml +3 -0
- package/docs/ARCHITECTURE-v0.2.md +269 -0
- package/docs/AUTO-DISCOVERY.md +111 -0
- package/docs/AUTOMATION-POLICIES.md +232 -0
- package/docs/CONTRATO-v0.1.md +195 -0
- package/docs/EMBEDDING-PROVIDERS.md +105 -0
- package/docs/OBSERVABILITY.md +241 -0
- package/docs/PA-UI-0-API-CONTRACT.md +802 -0
- package/docs/PERFORMANCE-BUDGETS.md +118 -0
- package/docs/PROJECT-AWARE-ARCHITECTURE.md +580 -0
- package/docs/PROJECT-AWARE-DATA-CONTRACT.md +411 -0
- package/docs/PROJECT-AWARE-ERROR-CONTRACT.md +112 -0
- package/docs/PROJECT-AWARE-SESSION-CONTRACT.md +120 -0
- package/docs/WORKSPACE-API.md +239 -0
- package/icon.svg +7 -0
- package/index.js +198 -0
- package/lib/audit-export.mjs +70 -0
- package/lib/audit.mjs +120 -0
- package/lib/auto-context.mjs +322 -0
- package/lib/automation.mjs +214 -0
- package/lib/chunk.mjs +100 -0
- package/lib/config-resolve.mjs +119 -0
- package/lib/context.mjs +150 -0
- package/lib/conversation-events.mjs +145 -0
- package/lib/db.mjs +309 -0
- package/lib/diagnose.mjs +197 -0
- package/lib/discovery.mjs +402 -0
- package/lib/doctor.mjs +82 -0
- package/lib/embed.mjs +96 -0
- package/lib/embedders.mjs +103 -0
- package/lib/errors.mjs +227 -0
- package/lib/exec-context.mjs +238 -0
- package/lib/extract.mjs +260 -0
- package/lib/harness-workspaces.mjs +85 -0
- package/lib/hash.mjs +34 -0
- package/lib/ingest.mjs +239 -0
- package/lib/inputs.mjs +67 -0
- package/lib/library-state.mjs +252 -0
- package/lib/maintenance.mjs +113 -0
- package/lib/metrics.mjs +164 -0
- package/lib/migrate.mjs +373 -0
- package/lib/operations.mjs +132 -0
- package/lib/pa-api.mjs +517 -0
- package/lib/paths.mjs +345 -0
- package/lib/policy.mjs +125 -0
- package/lib/profile.mjs +128 -0
- package/lib/readmodel.mjs +159 -0
- package/lib/recovery.mjs +557 -0
- package/lib/registry-schema.mjs +206 -0
- package/lib/registry.mjs +406 -0
- package/lib/resolve.mjs +311 -0
- package/lib/retention.mjs +143 -0
- package/lib/revocation.mjs +124 -0
- package/lib/roots-structure.mjs +224 -0
- package/lib/schema.mjs +173 -0
- package/lib/scope-ops.mjs +379 -0
- package/lib/scope-stores.mjs +128 -0
- package/lib/search.mjs +345 -0
- package/lib/selection.mjs +150 -0
- package/lib/server.mjs +335 -0
- package/lib/session-identity.mjs +51 -0
- package/lib/sessions.mjs +343 -0
- package/lib/sync-scheduler.mjs +354 -0
- package/lib/sync.mjs +755 -0
- package/lib/tags.mjs +45 -0
- package/lib/tools.mjs +364 -0
- package/lib/trusted-roots.mjs +149 -0
- package/lib/worker-context.mjs +22 -0
- package/package.json +67 -5
package/lib/resolve.mjs
ADDED
|
@@ -0,0 +1,311 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Resolución de ámbitos (PA2.4/PA2.6): determinista y fail-closed.
|
|
3
|
+
*
|
|
4
|
+
* Orden del contrato de sesión:
|
|
5
|
+
* 1. identidad estable del host (atada al perfil),
|
|
6
|
+
* 2. selección explícita persistida,
|
|
7
|
+
* 3. si no hay selección, `cwd` contra raíces autorizadas de proyectos activos,
|
|
8
|
+
* 4. exactamente una coincidencia; cero → `scope-unresolved`, varias → `scope-ambiguous`.
|
|
9
|
+
*
|
|
10
|
+
* No hay proyecto por defecto, ni «el último», ni «el primero». Una selección explícita
|
|
11
|
+
* incompatible con el `cwd` no se corrige sola: se rechaza como ambigua.
|
|
12
|
+
*/
|
|
13
|
+
|
|
14
|
+
import { RagError } from './errors.mjs';
|
|
15
|
+
import { appendRegistryAudit, getProject, pathKeyFor } from './registry.mjs';
|
|
16
|
+
import { findProjectBoundary, registerDiscoveredProject } from './discovery.mjs';
|
|
17
|
+
import { normalizeWorkspace, openProjectForCwd, openProjectForSession } from './harness-workspaces.mjs';
|
|
18
|
+
import { assertSessionId } from './session-identity.mjs';
|
|
19
|
+
import { effectiveScopes, getSession } from './sessions.mjs';
|
|
20
|
+
import { trustedRootFor } from './trusted-roots.mjs';
|
|
21
|
+
|
|
22
|
+
function deny(db, { sessionId, identity, code, message, details, now }) {
|
|
23
|
+
try {
|
|
24
|
+
appendRegistryAudit(db, {
|
|
25
|
+
at: now,
|
|
26
|
+
actor: 'host',
|
|
27
|
+
sessionId: sessionId ?? identity?.sessionId ?? null,
|
|
28
|
+
action: 'scope.resolve',
|
|
29
|
+
target: details?.project_id ?? details?.cwd ?? 'scope',
|
|
30
|
+
outcome: 'denied',
|
|
31
|
+
detail: JSON.stringify({ code, ...details }),
|
|
32
|
+
});
|
|
33
|
+
} catch {
|
|
34
|
+
// si la auditoría falla, el rechazo sigue siendo un rechazo
|
|
35
|
+
}
|
|
36
|
+
throw new RagError(code, message, { details });
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
function insideRoot(cwdKey, rootKey) {
|
|
40
|
+
if (!cwdKey || !rootKey) return false;
|
|
41
|
+
if (cwdKey === rootKey) return true;
|
|
42
|
+
const prefix = rootKey.endsWith('/') ? rootKey : `${rootKey}/`;
|
|
43
|
+
return cwdKey.startsWith(prefix);
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
function matchingProjects(db, cwdKey) {
|
|
47
|
+
const rows = db.prepare(`SELECT p.id AS project_id, p.name AS project_name, r.path, r.path_key
|
|
48
|
+
FROM roots r JOIN projects p ON p.id = r.scope_id
|
|
49
|
+
WHERE r.scope_kind='prj' AND r.state='authorized' AND p.status='active'
|
|
50
|
+
ORDER BY r.path`).all();
|
|
51
|
+
return rows.filter((row) => insideRoot(cwdKey, row.path_key));
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
/**
|
|
55
|
+
* Con raíces anidadas (un proyecto dentro del directorio de otro) gana la raíz más específica:
|
|
56
|
+
* se descarta toda coincidencia cuyo directorio contenga a otra coincidencia distinta. Si tras
|
|
57
|
+
* podar quedan dos proyectos hermanos, la coincidencia sigue siendo ambigua.
|
|
58
|
+
*/
|
|
59
|
+
function mostSpecific(matches) {
|
|
60
|
+
return matches.filter((row) => !matches.some((other) => (
|
|
61
|
+
other.project_id !== row.project_id
|
|
62
|
+
&& other.path_key !== row.path_key
|
|
63
|
+
&& other.path_key.startsWith(`${row.path_key}/`)
|
|
64
|
+
)));
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
/**
|
|
68
|
+
* Auto-descubrimiento en el camino de resolución.
|
|
69
|
+
*
|
|
70
|
+
* Si la persona tiene un proyecto abierto en Harness, ese proyecto es el candidato natural
|
|
71
|
+
* aunque el `cwd` de la sesión apunte a su carpeta contenedora (p. ej. `htdocs`): abrir
|
|
72
|
+
* `plugins-dhs` no autoriza a sus hermanos. Si no hay workspace abierto, se mantiene el
|
|
73
|
+
* descubrimiento por `cwd` dentro de un workspace confiable.
|
|
74
|
+
*
|
|
75
|
+
* En ambos casos la lectura exige un `trusted root` explícito que cubra el proyecto. Un
|
|
76
|
+
* proyecto abierto sin autorización devuelve una denegación con el comando exacto que la
|
|
77
|
+
* persona debe ejecutar; nunca se concede autorización por el hecho de estar abierto.
|
|
78
|
+
*/
|
|
79
|
+
function autoDiscoverCwd(db, { cwd, sessionId, openProjects, now }) {
|
|
80
|
+
const cwdKey = typeof cwd === 'string' && cwd.trim() !== '' ? pathKeyFor(cwd) : null;
|
|
81
|
+
const open = openProjectForCwd(openProjects, cwdKey)
|
|
82
|
+
?? openProjectForSession(openProjects, sessionId);
|
|
83
|
+
|
|
84
|
+
let boundary = null;
|
|
85
|
+
if (open) {
|
|
86
|
+
boundary = { path: open.path, name: open.title, type: 'harness-workspace', indicators: [] };
|
|
87
|
+
} else {
|
|
88
|
+
const trust = trustedRootFor(db, cwdKey);
|
|
89
|
+
if (!trust || trust.readAuthorization !== true) return { registered: false };
|
|
90
|
+
try {
|
|
91
|
+
boundary = findProjectBoundary(cwd, { withinPath: trust.path });
|
|
92
|
+
} catch {
|
|
93
|
+
return { registered: false };
|
|
94
|
+
}
|
|
95
|
+
if (!boundary) return { registered: false };
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
const boundaryKey = pathKeyFor(boundary.path);
|
|
99
|
+
const authorization = trustedRootFor(db, boundaryKey);
|
|
100
|
+
if (!authorization || authorization.readAuthorization !== true) {
|
|
101
|
+
return {
|
|
102
|
+
registered: false,
|
|
103
|
+
denied: {
|
|
104
|
+
code: 'scope-unresolved',
|
|
105
|
+
message: 'el proyecto abierto en Harness no está autorizado para lectura',
|
|
106
|
+
details: {
|
|
107
|
+
session_id: sessionId,
|
|
108
|
+
cwd: cwd ?? null,
|
|
109
|
+
reason: 'project-not-authorized',
|
|
110
|
+
project: { id: open?.id ?? null, path: open?.path ?? boundary.path, title: boundary.name },
|
|
111
|
+
command: `node bin/lifecode-rag.mjs trust add --path "${open?.path ?? boundary.path}"`,
|
|
112
|
+
},
|
|
113
|
+
},
|
|
114
|
+
};
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
try {
|
|
118
|
+
const result = registerDiscoveredProject(db, {
|
|
119
|
+
path: boundary.path,
|
|
120
|
+
name: boundary.name,
|
|
121
|
+
type: boundary.type,
|
|
122
|
+
indicators: boundary.indicators,
|
|
123
|
+
source: open ? 'harness' : 'auto',
|
|
124
|
+
authorization: 'read',
|
|
125
|
+
now,
|
|
126
|
+
});
|
|
127
|
+
return { registered: result.registeredRoot !== false, projectId: result.projectId };
|
|
128
|
+
} catch {
|
|
129
|
+
return { registered: false };
|
|
130
|
+
}
|
|
131
|
+
}
|
|
132
|
+
|
|
133
|
+
function scopesOf(db, identity, expectedProfileKey) {
|
|
134
|
+
return effectiveScopes(db, { identity, expectedProfileKey });
|
|
135
|
+
}
|
|
136
|
+
|
|
137
|
+
/**
|
|
138
|
+
* Resuelve el ámbito de una sesión. Devuelve la selección efectiva sin abrir almacenes de ámbito
|
|
139
|
+
* (eso corresponde a PA3) y sin persistir una selección derivada de `cwd`.
|
|
140
|
+
*/
|
|
141
|
+
export function resolveScope(db, {
|
|
142
|
+
identity, expectedProfileKey, cwd = null, openProjects = [], now = Date.now(),
|
|
143
|
+
} = {}) {
|
|
144
|
+
if (!identity || typeof identity !== 'object') {
|
|
145
|
+
throw new RagError('session-invalid', 'falta la identidad de sesión', { details: { reason: 'missing-identity' } });
|
|
146
|
+
}
|
|
147
|
+
const sessionId = assertSessionId(identity.sessionId);
|
|
148
|
+
const cwdKey = typeof cwd === 'string' && cwd.trim() !== '' ? pathKeyFor(cwd) : null;
|
|
149
|
+
// Se normaliza en la frontera: cualquier llamante puede pasar la forma cruda del host.
|
|
150
|
+
const open = (Array.isArray(openProjects) ? openProjects : [])
|
|
151
|
+
.map((entry) => normalizeWorkspace(entry))
|
|
152
|
+
.filter(Boolean);
|
|
153
|
+
|
|
154
|
+
if (identity.profileKey !== expectedProfileKey) {
|
|
155
|
+
deny(db, {
|
|
156
|
+
sessionId, identity, code: 'session-invalid',
|
|
157
|
+
message: 'la sesión pertenece a otro perfil',
|
|
158
|
+
details: { reason: 'profile-mismatch' }, now,
|
|
159
|
+
});
|
|
160
|
+
}
|
|
161
|
+
|
|
162
|
+
const session = getSession(db, sessionId);
|
|
163
|
+
|
|
164
|
+
if (session) {
|
|
165
|
+
if (session.state === 'expired') {
|
|
166
|
+
// Una sesión terminada también es una denegación: si no se audita, la cadena miente por omisión.
|
|
167
|
+
deny(db, {
|
|
168
|
+
sessionId, identity, code: 'session-expired',
|
|
169
|
+
message: 'la sesión está terminada',
|
|
170
|
+
details: { session_id: sessionId, reason: 'session-expired', expires_at: session.expires_at }, now,
|
|
171
|
+
});
|
|
172
|
+
}
|
|
173
|
+
if (session.state === 'invalidated') {
|
|
174
|
+
deny(db, {
|
|
175
|
+
sessionId, identity, code: 'scope-forbidden',
|
|
176
|
+
message: 'la selección de la sesión fue invalidada',
|
|
177
|
+
details: { session_id: sessionId, reason: session.invalid_reason }, now,
|
|
178
|
+
});
|
|
179
|
+
}
|
|
180
|
+
const project = getProject(db, session.project_id);
|
|
181
|
+
if (!project || project.status !== 'active') {
|
|
182
|
+
deny(db, {
|
|
183
|
+
sessionId, identity, code: 'scope-forbidden',
|
|
184
|
+
message: 'el proyecto seleccionado no está activo',
|
|
185
|
+
details: { session_id: sessionId, project_id: session.project_id, reason: 'project-archived' }, now,
|
|
186
|
+
});
|
|
187
|
+
}
|
|
188
|
+
if (cwdKey) {
|
|
189
|
+
const matches = mostSpecific(matchingProjects(db, cwdKey));
|
|
190
|
+
const projects = new Set(matches.map((row) => row.project_id));
|
|
191
|
+
if (projects.size > 1 || (projects.size === 1 && !projects.has(session.project_id))) {
|
|
192
|
+
deny(db, {
|
|
193
|
+
sessionId, identity, code: 'scope-ambiguous',
|
|
194
|
+
message: 'el directorio de trabajo no corresponde a la selección explícita',
|
|
195
|
+
details: {
|
|
196
|
+
session_id: sessionId,
|
|
197
|
+
selected_project_id: session.project_id,
|
|
198
|
+
candidates: matches.map((row) => ({ project_id: row.project_id, path: row.path })),
|
|
199
|
+
}, now,
|
|
200
|
+
});
|
|
201
|
+
}
|
|
202
|
+
}
|
|
203
|
+
const effective = scopesOf(db, identity, expectedProfileKey);
|
|
204
|
+
succeed(db, { sessionId, projectId: effective.project.id, source: 'explicit', effective, now });
|
|
205
|
+
return resultOf(sessionId, 'explicit', effective);
|
|
206
|
+
}
|
|
207
|
+
|
|
208
|
+
if (!cwdKey) {
|
|
209
|
+
deny(db, {
|
|
210
|
+
sessionId, identity, code: 'scope-unresolved',
|
|
211
|
+
message: 'la sesión no tiene selección y no hay directorio de trabajo verificable',
|
|
212
|
+
details: { session_id: sessionId, cwd: null }, now,
|
|
213
|
+
});
|
|
214
|
+
}
|
|
215
|
+
let matches = matchingProjects(db, cwdKey);
|
|
216
|
+
if (matches.length === 0) {
|
|
217
|
+
const attempt = autoDiscoverCwd(db, { cwd, sessionId, openProjects: open, now });
|
|
218
|
+
if (attempt.denied) {
|
|
219
|
+
deny(db, { sessionId, identity, ...attempt.denied, now });
|
|
220
|
+
}
|
|
221
|
+
if (attempt.registered && attempt.projectId) {
|
|
222
|
+
// El proyecto abierto puede ser hijo del `cwd` (la carpeta contenedora): no es una
|
|
223
|
+
// coincidencia por prefijo, así que se resuelve directamente por su id.
|
|
224
|
+
const effective = effectiveScopesForProject(db, attempt.projectId);
|
|
225
|
+
succeed(db, { sessionId, projectId: attempt.projectId, source: 'cwd', effective, now });
|
|
226
|
+
return resultOf(sessionId, 'cwd', effective);
|
|
227
|
+
}
|
|
228
|
+
if (attempt.registered) matches = matchingProjects(db, cwdKey);
|
|
229
|
+
}
|
|
230
|
+
matches = mostSpecific(matches);
|
|
231
|
+
const projects = new Set(matches.map((row) => row.project_id));
|
|
232
|
+
if (projects.size === 0) {
|
|
233
|
+
deny(db, {
|
|
234
|
+
sessionId, identity, code: 'scope-unresolved',
|
|
235
|
+
message: 'el directorio de trabajo no está dentro de ninguna raíz autorizada',
|
|
236
|
+
details: {
|
|
237
|
+
session_id: sessionId,
|
|
238
|
+
cwd: cwd ?? null,
|
|
239
|
+
open_projects: open.map((project) => ({ id: project.id, path: project.path, title: project.title })),
|
|
240
|
+
}, now,
|
|
241
|
+
});
|
|
242
|
+
}
|
|
243
|
+
if (projects.size > 1) {
|
|
244
|
+
deny(db, {
|
|
245
|
+
sessionId, identity, code: 'scope-ambiguous',
|
|
246
|
+
message: 'el directorio de trabajo coincide con más de un proyecto',
|
|
247
|
+
details: {
|
|
248
|
+
session_id: sessionId,
|
|
249
|
+
candidates: matches.map((row) => ({ project_id: row.project_id, path: row.path })),
|
|
250
|
+
}, now,
|
|
251
|
+
});
|
|
252
|
+
}
|
|
253
|
+
const [match] = matches;
|
|
254
|
+
const effective = effectiveScopesForProject(db, match.project_id);
|
|
255
|
+
succeed(db, { sessionId, projectId: match.project_id, source: 'cwd', effective, now });
|
|
256
|
+
return resultOf(sessionId, 'cwd', effective);
|
|
257
|
+
}
|
|
258
|
+
|
|
259
|
+
function effectiveScopesForProject(db, projectId) {
|
|
260
|
+
const project = getProject(db, projectId);
|
|
261
|
+
if (!project || project.status !== 'active') {
|
|
262
|
+
throw new RagError('scope-forbidden', 'el proyecto no está activo', {
|
|
263
|
+
details: { project_id: projectId, reason: 'project-archived' },
|
|
264
|
+
});
|
|
265
|
+
}
|
|
266
|
+
const libraries = db.prepare(`SELECT l.* FROM grants g
|
|
267
|
+
JOIN libraries l ON l.id = g.library_id
|
|
268
|
+
WHERE g.project_id = ? AND g.revoked_at IS NULL AND l.status = 'active'
|
|
269
|
+
ORDER BY l.name, l.id`).all(projectId);
|
|
270
|
+
const rootsOf = (scopeKind, scopeId) => db.prepare(
|
|
271
|
+
`SELECT id, path FROM roots WHERE scope_kind=? AND scope_id=? AND state='authorized' ORDER BY path`,
|
|
272
|
+
).all(scopeKind, scopeId);
|
|
273
|
+
const scopes = [
|
|
274
|
+
{ kind: 'prj', id: project.id, name: project.name, roots: rootsOf('prj', project.id) },
|
|
275
|
+
...libraries.map((library) => ({
|
|
276
|
+
kind: 'lib', id: library.id, name: library.name, roots: rootsOf('lib', library.id),
|
|
277
|
+
})),
|
|
278
|
+
];
|
|
279
|
+
if (scopes.length > 8) {
|
|
280
|
+
throw new RagError('scope-too-many', 'la selección supera el máximo de ámbitos', {
|
|
281
|
+
details: { project_id: projectId, scopes: scopes.map((scope) => scope.id), limit: 8 },
|
|
282
|
+
});
|
|
283
|
+
}
|
|
284
|
+
return { project, scopes, scopeCount: scopes.length, session: null };
|
|
285
|
+
}
|
|
286
|
+
|
|
287
|
+
function succeed(db, { sessionId, projectId, source, effective, now }) {
|
|
288
|
+
appendRegistryAudit(db, {
|
|
289
|
+
at: now,
|
|
290
|
+
actor: 'host',
|
|
291
|
+
sessionId,
|
|
292
|
+
action: 'scope.resolve',
|
|
293
|
+
target: projectId,
|
|
294
|
+
outcome: 'ok',
|
|
295
|
+
detail: JSON.stringify({ project_id: projectId, source, scopes: effective.scopeCount }),
|
|
296
|
+
});
|
|
297
|
+
}
|
|
298
|
+
|
|
299
|
+
function resultOf(sessionId, source, effective) {
|
|
300
|
+
return {
|
|
301
|
+
sessionId,
|
|
302
|
+
projectId: effective.project.id,
|
|
303
|
+
projectName: effective.project.name,
|
|
304
|
+
source,
|
|
305
|
+
revision: effective.session?.revision ?? null,
|
|
306
|
+
scopes: effective.scopes.map((scope) => ({
|
|
307
|
+
kind: scope.kind, id: scope.id, name: scope.name, roots: scope.roots.map((root) => root.path),
|
|
308
|
+
})),
|
|
309
|
+
scopeCount: effective.scopeCount,
|
|
310
|
+
};
|
|
311
|
+
}
|
|
@@ -0,0 +1,143 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Retención y archivado de metadatos (PA4-G, observación O-PA0-3).
|
|
3
|
+
*
|
|
4
|
+
* Regla de PA4: este módulo **no borra nada**. Planifica y archiva; ejecutar una retención destructiva
|
|
5
|
+
* exige una política humana aprobada que todavía no existe (propuesta en el informe PA4). Por eso no
|
|
6
|
+
* hay `applyRetention()` ni `DELETE`: si en el futuro se autoriza, tendrá que entrar aquí y pasar por
|
|
7
|
+
* revisión, no colarse desde otro módulo.
|
|
8
|
+
*
|
|
9
|
+
* Qué es retenible y qué no:
|
|
10
|
+
* - `session_scope` expiradas o invalidadas: metadatos operativos, sin valor probatorio propio; su
|
|
11
|
+
* rastro histórico ya vive en `audit_registry` (`session.terminate`, `session.invalidate`).
|
|
12
|
+
* - `operations`/`operation_steps` terminadas: si se archivan, se archivan juntas (los pasos van con
|
|
13
|
+
* su operación) y nunca una fila `started`: esa es una operación interrumpida y se reconcilia, no
|
|
14
|
+
* se borra.
|
|
15
|
+
* - `audit_registry` y la `audit` de cada almacén: **no se borran ni se compactan**. Son la cadena de
|
|
16
|
+
* integridad; archivarlas es copiar, no sustituir. `exportRegistryAuditSlice` copia un rango
|
|
17
|
+
* verificando la cadena antes de escribir.
|
|
18
|
+
*/
|
|
19
|
+
|
|
20
|
+
import { createHash } from 'node:crypto';
|
|
21
|
+
import { writeFileSync } from 'node:fs';
|
|
22
|
+
|
|
23
|
+
import { RagError } from './errors.mjs';
|
|
24
|
+
import { canonicalJson } from './audit.mjs';
|
|
25
|
+
import { appendRegistryAudit, registryAuditHash } from './registry.mjs';
|
|
26
|
+
|
|
27
|
+
/** Días de conservación propuestos. No son política aprobada: son la propuesta del informe PA4. */
|
|
28
|
+
export const RETENTION_PROPOSAL = Object.freeze({
|
|
29
|
+
sessionScopeDays: 90,
|
|
30
|
+
finishedOperationsDays: 180,
|
|
31
|
+
dailyMetricsDays: 400,
|
|
32
|
+
});
|
|
33
|
+
|
|
34
|
+
const DAY_MS = 86_400_000;
|
|
35
|
+
|
|
36
|
+
/** Día UTC `YYYY-MM-DD` de un instante, que es el formato de `metrics_daily.day`. */
|
|
37
|
+
export function dayOf(instant) {
|
|
38
|
+
return new Date(instant).toISOString().slice(0, 10);
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
/**
|
|
42
|
+
* Calcula qué se podría archivar y cuánto ocupa, sin tocar nada. Devuelve también lo que la política
|
|
43
|
+
* **nunca** tocaría, para que la decisión humana se tome con el número completo delante.
|
|
44
|
+
*/
|
|
45
|
+
export function planRetention(registryDb, { now = Date.now(), policy = RETENTION_PROPOSAL } = {}) {
|
|
46
|
+
const sessionCutoff = new Date(now - policy.sessionScopeDays * DAY_MS).toISOString();
|
|
47
|
+
const metricsCutoff = dayOf(now - policy.dailyMetricsDays * DAY_MS);
|
|
48
|
+
const count = (sql, ...params) => Number(registryDb.prepare(sql).get(...params)?.n ?? 0);
|
|
49
|
+
|
|
50
|
+
const expiredSessions = count(
|
|
51
|
+
`SELECT COUNT(*) AS n FROM session_scope
|
|
52
|
+
WHERE state IN ('expired','invalidated') AND updated_at < ?`, sessionCutoff,
|
|
53
|
+
);
|
|
54
|
+
const activeSessions = count(`SELECT COUNT(*) AS n FROM session_scope WHERE state = 'active'`);
|
|
55
|
+
const unfinishedOperations = count(`SELECT COUNT(*) AS n FROM operations WHERE state = 'started'`);
|
|
56
|
+
const finishedOperations = count(
|
|
57
|
+
`SELECT COUNT(*) AS n FROM operations WHERE state <> 'started'`,
|
|
58
|
+
);
|
|
59
|
+
const auditEntries = count('SELECT COUNT(*) AS n FROM audit_registry');
|
|
60
|
+
const auditHeadHash = registryDb.prepare(`SELECT value FROM meta WHERE key='audit_head_hash'`).get()?.value ?? null;
|
|
61
|
+
|
|
62
|
+
return {
|
|
63
|
+
policy: { ...policy, approved: false, destructive: false },
|
|
64
|
+
asOf: new Date(now).toISOString(),
|
|
65
|
+
candidates: {
|
|
66
|
+
expiredSessions,
|
|
67
|
+
finishedOperations,
|
|
68
|
+
metricsBefore: metricsCutoff,
|
|
69
|
+
},
|
|
70
|
+
protected: {
|
|
71
|
+
activeSessions,
|
|
72
|
+
unfinishedOperations,
|
|
73
|
+
auditRegistryEntries: auditEntries,
|
|
74
|
+
auditHeadHash,
|
|
75
|
+
note: 'la auditoría no se borra ni se compacta; sólo se copia',
|
|
76
|
+
},
|
|
77
|
+
note: 'plan de sólo lectura: PA4 no elimina ni compacta metadatos sin política humana aprobada',
|
|
78
|
+
};
|
|
79
|
+
}
|
|
80
|
+
|
|
81
|
+
/**
|
|
82
|
+
* Copia un rango de la auditoría del registro a JSONL verificando la cadena antes de escribir.
|
|
83
|
+
* No modifica la base. La cabecera del fichero declara el rango y el hash de cabeza para que la copia
|
|
84
|
+
* sea comprobable por sí misma.
|
|
85
|
+
*/
|
|
86
|
+
export function exportRegistryAuditSlice(registryDb, { fromSeq = 1, toSeq = null, path, now = Date.now() } = {}) {
|
|
87
|
+
if (typeof path !== 'string' || path.length === 0) {
|
|
88
|
+
throw new RagError('invalid-argument', 'la exportación necesita una ruta de destino');
|
|
89
|
+
}
|
|
90
|
+
const rows = registryDb.prepare(
|
|
91
|
+
`SELECT seq, at, actor, session_id, action, target, outcome, detail, prev_hash, hash
|
|
92
|
+
FROM audit_registry WHERE seq >= ? AND seq <= COALESCE(?, seq) ORDER BY seq ASC`,
|
|
93
|
+
).all(Number(fromSeq), toSeq === null ? null : Number(toSeq));
|
|
94
|
+
|
|
95
|
+
let previous = fromSeq > 1
|
|
96
|
+
? (registryDb.prepare('SELECT hash FROM audit_registry WHERE seq = ?').get(Number(fromSeq) - 1)?.hash ?? null)
|
|
97
|
+
: '0'.repeat(64);
|
|
98
|
+
if (previous === null) {
|
|
99
|
+
throw new RagError('registry-corrupt', 'el rango de auditoría no continúa una cadena conocida', {
|
|
100
|
+
details: { fromSeq },
|
|
101
|
+
});
|
|
102
|
+
}
|
|
103
|
+
const seedHash = previous;
|
|
104
|
+
for (const row of rows) {
|
|
105
|
+
const expected = registryAuditHash(previous, {
|
|
106
|
+
at: row.at, actor: row.actor, sessionId: row.session_id, action: row.action,
|
|
107
|
+
target: row.target, outcome: row.outcome, detail: row.detail,
|
|
108
|
+
});
|
|
109
|
+
if (expected !== row.hash) {
|
|
110
|
+
throw new RagError('registry-corrupt', 'la cadena de auditoría del registro no verifica en el rango exportado', {
|
|
111
|
+
details: { seq: row.seq, expected, actual: row.hash },
|
|
112
|
+
});
|
|
113
|
+
}
|
|
114
|
+
previous = row.hash;
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
const header = canonicalJson({
|
|
118
|
+
kind: 'lifecode-rag/registry-audit-slice',
|
|
119
|
+
exportedAt: new Date(now).toISOString(),
|
|
120
|
+
fromSeq: Number(fromSeq),
|
|
121
|
+
toSeq: rows.length > 0 ? rows.at(-1).seq : Number(fromSeq) - 1,
|
|
122
|
+
previousHash: fromSeq > 1 ? seedHash : null,
|
|
123
|
+
headHash: rows.length > 0 ? rows.at(-1).hash : previous,
|
|
124
|
+
});
|
|
125
|
+
const lines = [header, ...rows.map((row) => canonicalJson(row))];
|
|
126
|
+
const body = `${lines.join('\n')}\n`;
|
|
127
|
+
writeFileSync(path, body, 'utf8');
|
|
128
|
+
const seal = createHash('sha256').update(body, 'utf8').digest('hex');
|
|
129
|
+
writeFileSync(`${path}.sha256`, `${seal} ${path.split(/[\\/]/).pop()}\n`, 'utf8');
|
|
130
|
+
|
|
131
|
+
// La exportación es una acción auditable, pero no destructiva: se deja rastro en el registro.
|
|
132
|
+
appendRegistryAudit(registryDb, {
|
|
133
|
+
at: now,
|
|
134
|
+
actor: 'human',
|
|
135
|
+
sessionId: null,
|
|
136
|
+
action: 'audit.export',
|
|
137
|
+
target: String(fromSeq),
|
|
138
|
+
outcome: 'ok',
|
|
139
|
+
detail: { entries: rows.length, path, seal },
|
|
140
|
+
});
|
|
141
|
+
|
|
142
|
+
return { entries: rows.length, bytes: Buffer.byteLength(body, 'utf8'), sha256: seal, path, fromSeq: Number(fromSeq) };
|
|
143
|
+
}
|
|
@@ -0,0 +1,124 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Revocación efectiva (PA4-B).
|
|
3
|
+
*
|
|
4
|
+
* PA3 fijaba la autorización al empezar la llamada: una consulta en curso terminaba con los ámbitos
|
|
5
|
+
* que ya había abierto. PA4 añade **puntos de control** que vuelven a leer el registro (sin caché de
|
|
6
|
+
* grants) y una garantía verificable:
|
|
7
|
+
*
|
|
8
|
+
* - Antes de abrir cada ámbito se comprueba que sigue autorizado.
|
|
9
|
+
* - Antes de devolver información al consumidor se comprueba otra vez el conjunto completo.
|
|
10
|
+
* - Si durante la operación se revoca un ámbito que la operación tenía autorizado, la operación
|
|
11
|
+
* **no devuelve resultados** de ningún ámbito: falla con `grant-revoked` y deja constancia en la
|
|
12
|
+
* auditoría del registro. Un resultado reducido no se presenta como exhaustivo (v0.1 no puede
|
|
13
|
+
* expresar `partial`).
|
|
14
|
+
*
|
|
15
|
+
* Latencias y límites, que se documentan en vez de prometerse:
|
|
16
|
+
* - El modelo de ejecución es de un solo hilo por proceso: un cambio hecho por *otra conexión* u otro
|
|
17
|
+
* proceso sólo puede confirmarse entre dos sentencias nuestras. La revocación se detecta como muy
|
|
18
|
+
* tarde en el siguiente punto de control, nunca en mitad de una sentencia SQLite propia.
|
|
19
|
+
* - Una escritura ya confirmada (`COMMIT`) no se revierte: la revocación impide seguir escribiendo y
|
|
20
|
+
* devolver datos, no deshace lo escrito. La atomicidad de una escritura termina en su `COMMIT`.
|
|
21
|
+
* - `grant-revoked` con `reason: 'revoked-during-operation'` significa «autorizado al abrir, no
|
|
22
|
+
* autorizado al devolver»; no hay resultados parciales que entregar.
|
|
23
|
+
*/
|
|
24
|
+
|
|
25
|
+
import { RagError } from './errors.mjs';
|
|
26
|
+
|
|
27
|
+
/**
|
|
28
|
+
* Estado de autorización actual, leído de la base del registro. Sin caché: cada llamada ve lo que
|
|
29
|
+
* hay comprometido en ese instante.
|
|
30
|
+
*/
|
|
31
|
+
export function currentAuthorization(db, { sessionId, projectId, sessionOptional = false } = {}) {
|
|
32
|
+
const session = db.prepare('SELECT * FROM session_scope WHERE session_id = ?').get(sessionId) ?? null;
|
|
33
|
+
if (!session) {
|
|
34
|
+
// Resolver por cwd no registra selección: sin fila de sesión la autorización es la del proyecto.
|
|
35
|
+
if (sessionOptional) return projectAuthorization(db, projectId);
|
|
36
|
+
return { ok: false, reason: 'session-missing', scopes: null };
|
|
37
|
+
}
|
|
38
|
+
if (session.state === 'expired') return { ok: false, reason: 'session-expired', scopes: null };
|
|
39
|
+
if (session.state === 'invalidated') {
|
|
40
|
+
return { ok: false, reason: 'session-invalidated', invalidReason: session.invalid_reason, scopes: null };
|
|
41
|
+
}
|
|
42
|
+
if (session.project_id !== projectId) {
|
|
43
|
+
return { ok: false, reason: 'selection-changed', projectId: session.project_id, scopes: null };
|
|
44
|
+
}
|
|
45
|
+
const effective = projectAuthorization(db, projectId);
|
|
46
|
+
if (!effective.ok) return effective;
|
|
47
|
+
return { ...effective, revision: session.revision };
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
/**
|
|
51
|
+
* Autorización que no depende de una selección explícita: proyecto activo + grants abiertos +
|
|
52
|
+
* bibliotecas activas.
|
|
53
|
+
*
|
|
54
|
+
* No exige que la biblioteca tenga una raíz autorizada: ése es un estado de *contenido* (una
|
|
55
|
+
* biblioteca recién concedida y todavía sin raíz), no de autorización. Si aquí se filtrara por raíz,
|
|
56
|
+
* el conjunto releído tendría menos ámbitos que la instantánea con la que se abrió la operación y
|
|
57
|
+
* cualquier llamada legítima fallaría con `grant-revoked` —una revocación que nadie hizo— dejando el
|
|
58
|
+
* proyecto inservible. La falta de raíz ya la trata la propia operación (ámbito sin nada que servir).
|
|
59
|
+
*/
|
|
60
|
+
export function projectAuthorization(db, projectId) {
|
|
61
|
+
const project = db.prepare('SELECT id, status FROM projects WHERE id = ?').get(projectId) ?? null;
|
|
62
|
+
if (!project) return { ok: false, reason: 'project-missing', scopes: null };
|
|
63
|
+
if (project.status !== 'active') return { ok: false, reason: 'project-archived', scopes: null };
|
|
64
|
+
const libraries = db.prepare(
|
|
65
|
+
`SELECT l.id FROM grants g
|
|
66
|
+
JOIN libraries l ON l.id = g.library_id
|
|
67
|
+
WHERE g.project_id = ? AND g.revoked_at IS NULL AND l.status = 'active'
|
|
68
|
+
ORDER BY l.name, l.id`,
|
|
69
|
+
).all(projectId).map((row) => row.id);
|
|
70
|
+
return {
|
|
71
|
+
ok: true,
|
|
72
|
+
reason: 'ok',
|
|
73
|
+
projectId,
|
|
74
|
+
revision: null,
|
|
75
|
+
libraries,
|
|
76
|
+
scopes: [projectId, ...libraries],
|
|
77
|
+
};
|
|
78
|
+
}
|
|
79
|
+
|
|
80
|
+
/** Diferencia de conjuntos de ámbitos: `revoked` son los que ya no están, `added` los nuevos. */
|
|
81
|
+
export function diffScopes(before = [], after = []) {
|
|
82
|
+
const previous = new Set(before);
|
|
83
|
+
const current = new Set(after);
|
|
84
|
+
return {
|
|
85
|
+
revoked: [...previous].filter((id) => !current.has(id)),
|
|
86
|
+
added: [...current].filter((id) => !previous.has(id)),
|
|
87
|
+
unchanged: [...current].filter((id) => previous.has(id)),
|
|
88
|
+
};
|
|
89
|
+
}
|
|
90
|
+
|
|
91
|
+
/** Error de revocación con motivo explícito y sin datos sensibles. */
|
|
92
|
+
export function revocationError({ revoked = [], reason = 'revoked-during-operation', tool = null, sessionId = null } = {}) {
|
|
93
|
+
return new RagError('grant-revoked', 'la autorización del ámbito se revocó durante la operación', {
|
|
94
|
+
details: {
|
|
95
|
+
reason,
|
|
96
|
+
tool,
|
|
97
|
+
sessionId,
|
|
98
|
+
scopes: revoked,
|
|
99
|
+
guarantee: 'la operación no devuelve resultados de ámbitos revocados',
|
|
100
|
+
},
|
|
101
|
+
});
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
/**
|
|
105
|
+
* Traduce un estado de autorización perdido a su error del contrato.
|
|
106
|
+
*/
|
|
107
|
+
export function authorizationLostError(authorization) {
|
|
108
|
+
if (authorization.reason === 'session-expired') {
|
|
109
|
+
return new RagError('session-expired', 'la sesión expiró durante la operación', { details: { reason: 'session-expired' } });
|
|
110
|
+
}
|
|
111
|
+
if (authorization.reason === 'session-invalidated') {
|
|
112
|
+
return new RagError('scope-forbidden', 'la sesión se invalidó durante la operación', {
|
|
113
|
+
details: { reason: authorization.invalidReason ?? 'admin' },
|
|
114
|
+
});
|
|
115
|
+
}
|
|
116
|
+
if (authorization.reason === 'project-archived') {
|
|
117
|
+
return new RagError('scope-forbidden', 'el proyecto se archivó durante la operación', {
|
|
118
|
+
details: { reason: 'project-archived' },
|
|
119
|
+
});
|
|
120
|
+
}
|
|
121
|
+
return new RagError('scope-forbidden', 'la autorización de la operación dejó de ser válida', {
|
|
122
|
+
details: { reason: authorization.reason },
|
|
123
|
+
});
|
|
124
|
+
}
|