@ignitionai/cogitator 0.4.1 → 0.5.1
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/README.md +45 -8
- package/dist/extensions/index.js +1 -1
- package/dist/src/classic-configuration.js +153 -0
- package/dist/src/cli.js +2 -3
- package/dist/src/conversations.js +9 -7
- package/dist/src/db.js +52 -3
- package/dist/src/default-agent.js +1 -1
- package/dist/src/durable/admission.js +131 -0
- package/dist/src/durable/approvals.js +171 -0
- package/dist/src/durable/compatibility.js +59 -0
- package/dist/src/durable/effect-gateway.js +68 -0
- package/dist/src/durable/lease.js +48 -0
- package/dist/src/durable/manager.js +167 -0
- package/dist/src/durable/mission-runtime.js +460 -0
- package/dist/src/durable/profile.js +79 -0
- package/dist/src/durable/workers.js +42 -0
- package/dist/src/execution/admission.js +45 -0
- package/dist/src/execution/confinement.js +108 -0
- package/dist/src/execution/container.js +102 -0
- package/dist/src/execution/egress.js +69 -0
- package/dist/src/groups.js +71 -0
- package/dist/src/host-pi.js +61 -0
- package/dist/src/pool.js +193 -72
- package/dist/src/provider-login.js +115 -0
- package/dist/src/registry.js +72 -14
- package/dist/src/runtime.js +92 -0
- package/dist/src/schemas.js +45 -0
- package/dist/src/server.js +423 -23
- package/dist/src/spawner.js +34 -12
- package/dist/src/workspace-files.js +6 -5
- package/dist/src/workspaces.js +19 -6
- package/package.json +8 -1
- package/web/dist/assets/BrandLogo3D-BvZPXohP.js +4035 -0
- package/web/dist/assets/index-7Dyl-4v7.css +1 -0
- package/web/dist/assets/index-CdqzcBU-.js +83 -0
- package/web/dist/index.html +2 -2
- package/web/dist/assets/index-D3Q54zLM.js +0 -83
- package/web/dist/assets/index-Kj5NVQYi.css +0 -1
|
@@ -0,0 +1,171 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Approbations persistées, grants révocables et receipts d'effets (Plan 0002 §5,
|
|
3
|
+
* ADR-008 D6, Skeptic S3, UA1) — vérité Durable (D4) : pending actions, grants
|
|
4
|
+
* et intents/receipts vivent dans le stockage Durable de la conversation.
|
|
5
|
+
*
|
|
6
|
+
* Contrats :
|
|
7
|
+
* - UNE action privilégiée ne peut être approuvée que si le SERVEUR a créé un
|
|
8
|
+
* pending action immuable (operation, target, artifact/argument digests,
|
|
9
|
+
* expiry, allowed uses) ; le client n'invente jamais l'action à approuver ;
|
|
10
|
+
* - le pending action est immuable : seul son état de décision change ;
|
|
11
|
+
* - le grant est vérifiable à la dispatch : digests exacts (artefact/arguments/
|
|
12
|
+
* opération/cible, S3 — pas de ref mutable), expiration, révocation, uses
|
|
13
|
+
* restants, recheck immédiat avant CHAQUE effet protégé ;
|
|
14
|
+
* - consommation du grant et association de l'intent (idempotency key) ATOMIQUES
|
|
15
|
+
* dans un même commit ;
|
|
16
|
+
* - denial/expiry/cancellation sont des événements distincts (UA1) ; une demande
|
|
17
|
+
* identique n'est jamais re-demandée en boucle ;
|
|
18
|
+
* - le receipt enregistre l'intent (clé d'idempotence) + l'issue OBSERVÉE côté
|
|
19
|
+
* distant : on ne déduit jamais le succès du texte du modèle.
|
|
20
|
+
*/
|
|
21
|
+
import { randomUUID } from "node:crypto";
|
|
22
|
+
import { defineDoc } from "@earendil-works/pi-durable";
|
|
23
|
+
import { digest } from "./profile.js";
|
|
24
|
+
export { digest };
|
|
25
|
+
const emptyApprovals = () => ({ pendingActions: [], grants: [], receipts: [] });
|
|
26
|
+
/** Document conversationnel unique : approbations et effets de la mission. */
|
|
27
|
+
export const MissionApprovals = defineDoc({
|
|
28
|
+
kind: "cogitator.mission-approvals",
|
|
29
|
+
version: 1,
|
|
30
|
+
scope: "conversation",
|
|
31
|
+
history: "latest",
|
|
32
|
+
fork: "initial",
|
|
33
|
+
initial: emptyApprovals,
|
|
34
|
+
});
|
|
35
|
+
// ---------- Erreurs de dispatch (motifs vérifiables, jamais génériques) ----------
|
|
36
|
+
export class GrantRejectedError extends Error {
|
|
37
|
+
reason;
|
|
38
|
+
constructor(reason) {
|
|
39
|
+
super(`effet protégé refusé : ${reason}`);
|
|
40
|
+
this.reason = reason;
|
|
41
|
+
this.name = "GrantRejectedError";
|
|
42
|
+
}
|
|
43
|
+
}
|
|
44
|
+
/** Recherche un grant valide pour l'effet EXACT, immédiatement avant la dispatch. */
|
|
45
|
+
export function findValidGrant(grants, effect, now) {
|
|
46
|
+
const candidates = grants.filter((g) => g.operation === effect.operation &&
|
|
47
|
+
g.target === effect.target &&
|
|
48
|
+
g.artifactDigest === effect.artifactDigest &&
|
|
49
|
+
g.argumentDigest === effect.argumentDigest);
|
|
50
|
+
if (candidates.length === 0)
|
|
51
|
+
return { reason: "aucun grant pour cette action exacte (artefact/arguments/cible figés, S3)" };
|
|
52
|
+
const revoked = candidates.find((g) => g.revoked);
|
|
53
|
+
if (revoked && candidates.every((g) => g.revoked))
|
|
54
|
+
return { reason: "grant révoqué : plus aucune dispatch future autorisée" };
|
|
55
|
+
const expired = candidates.find((g) => g.expiresAt <= now);
|
|
56
|
+
if (expired && candidates.every((g) => g.expiresAt <= now || g.revoked)) {
|
|
57
|
+
return { reason: "grant expiré : renouvellement owner requis (l'expiration reste visible, UA1)" };
|
|
58
|
+
}
|
|
59
|
+
const usable = candidates.find((g) => !g.revoked && g.expiresAt > now && g.remainingUses > 0);
|
|
60
|
+
if (!usable)
|
|
61
|
+
return { reason: "grant épuisé (uses restants = 0)" };
|
|
62
|
+
return { grant: usable };
|
|
63
|
+
}
|
|
64
|
+
/**
|
|
65
|
+
* Consommation atomique : décrémente le grant ET associe l'intent (receipt
|
|
66
|
+
* "intent_committed" avec la clé d'idempotence et la tâche) dans la MÊME
|
|
67
|
+
* mutation de document. Une tentative déjà associée à cette clé n'est jamais
|
|
68
|
+
* re-consommée : on renvoie le receipt existant (déduplication/reprise).
|
|
69
|
+
*/
|
|
70
|
+
export function consumeGrantForEffect(doc, effect, now) {
|
|
71
|
+
const prior = doc.receipts.find((r) => r.intentKey === effect.intentKey);
|
|
72
|
+
if (prior)
|
|
73
|
+
return { kind: "duplicate", receipt: prior };
|
|
74
|
+
const found = findValidGrant(doc.grants, effect, now);
|
|
75
|
+
if ("reason" in found)
|
|
76
|
+
return { kind: "rejected", reason: found.reason };
|
|
77
|
+
found.grant.remainingUses -= 1;
|
|
78
|
+
doc.receipts.push({
|
|
79
|
+
...effect,
|
|
80
|
+
grantId: found.grant.id,
|
|
81
|
+
taskId: effect.taskId,
|
|
82
|
+
status: "intent_committed",
|
|
83
|
+
updatedAt: now,
|
|
84
|
+
});
|
|
85
|
+
return { kind: "consumed" };
|
|
86
|
+
}
|
|
87
|
+
/**
|
|
88
|
+
* Crée un pending action côté serveur. Une demande IDENTIQUE (mêmes digests +
|
|
89
|
+
* opération + cible) déjà pending ou déjà déniée n'est pas dupliquée (UA1) :
|
|
90
|
+
* on renvoie l'existant. Champs de scope immuables après création.
|
|
91
|
+
*/
|
|
92
|
+
export function createPendingAction(doc, input, now) {
|
|
93
|
+
const identical = doc.pendingActions.find((p) => p.decision !== "approved" &&
|
|
94
|
+
p.operation === input.operation &&
|
|
95
|
+
p.target === input.target &&
|
|
96
|
+
p.artifactDigest === input.artifactDigest &&
|
|
97
|
+
p.argumentDigest === input.argumentDigest);
|
|
98
|
+
if (identical)
|
|
99
|
+
return identical;
|
|
100
|
+
const action = {
|
|
101
|
+
...input,
|
|
102
|
+
id: randomUUID(),
|
|
103
|
+
createdAt: now,
|
|
104
|
+
decision: "pending",
|
|
105
|
+
decidedAt: 0,
|
|
106
|
+
};
|
|
107
|
+
doc.pendingActions.push(action);
|
|
108
|
+
return action;
|
|
109
|
+
}
|
|
110
|
+
/**
|
|
111
|
+
* Décision owner sur un pending action immuable. Approuver crée le grant
|
|
112
|
+
* (copie des digests figés, expiry, allowed uses) ; dénier est durable et ne
|
|
113
|
+
* re-demandera jamais l'action identique. Les décisions ne se réécrivent pas.
|
|
114
|
+
*/
|
|
115
|
+
export function decidePendingAction(doc, pendingActionId, decision, now, denialReason) {
|
|
116
|
+
const action = doc.pendingActions.find((p) => p.id === pendingActionId);
|
|
117
|
+
if (!action)
|
|
118
|
+
return { kind: "error", reason: "pending action introuvable (le client ne peut pas en inventer un)" };
|
|
119
|
+
if (action.decision !== "pending")
|
|
120
|
+
return { kind: "error", reason: `décision déjà enregistrée (${action.decision}) — les décisions sont durables` };
|
|
121
|
+
if (action.expiresAt <= now)
|
|
122
|
+
return { kind: "error", reason: "pending action expiré : renouveler ou annuler (l'expiration reste visible, UA1)" };
|
|
123
|
+
action.decision = decision;
|
|
124
|
+
action.decidedAt = now;
|
|
125
|
+
if (decision === "denied")
|
|
126
|
+
action.denialReason = denialReason ?? "refus owner";
|
|
127
|
+
if (decision === "approved") {
|
|
128
|
+
const grant = {
|
|
129
|
+
operation: action.operation,
|
|
130
|
+
target: action.target,
|
|
131
|
+
artifactDigest: action.artifactDigest,
|
|
132
|
+
argumentDigest: action.argumentDigest,
|
|
133
|
+
id: randomUUID(),
|
|
134
|
+
pendingActionId: action.id,
|
|
135
|
+
expiresAt: action.expiresAt,
|
|
136
|
+
remainingUses: action.allowedUses,
|
|
137
|
+
revoked: false,
|
|
138
|
+
decidedAt: now,
|
|
139
|
+
};
|
|
140
|
+
doc.grants.push(grant);
|
|
141
|
+
return { kind: "decided", pendingAction: action, grant };
|
|
142
|
+
}
|
|
143
|
+
return { kind: "decided", pendingAction: action };
|
|
144
|
+
}
|
|
145
|
+
/** Révocation : bloque les FUTURES dispatches ; n'annule pas un effet déjà accepté. */
|
|
146
|
+
export function revokeGrant(doc, grantId) {
|
|
147
|
+
const grant = doc.grants.find((g) => g.id === grantId);
|
|
148
|
+
if (!grant)
|
|
149
|
+
return { ok: false, reason: "grant introuvable" };
|
|
150
|
+
grant.revoked = true;
|
|
151
|
+
return { ok: true };
|
|
152
|
+
}
|
|
153
|
+
/** Enregistre l'issue OBSERVÉE d'une tentative déjà associée (jamais inférée). */
|
|
154
|
+
export function recordObservedReceipt(doc, intentKey, observed, now) {
|
|
155
|
+
const receipt = doc.receipts.find((r) => r.intentKey === intentKey);
|
|
156
|
+
if (!receipt)
|
|
157
|
+
return { ok: false, reason: "intent inconnu : la tentative n'a pas été associée à un grant" };
|
|
158
|
+
receipt.status = "observed";
|
|
159
|
+
receipt.observed = { at: now, ...observed };
|
|
160
|
+
receipt.updatedAt = now;
|
|
161
|
+
return { ok: true, receipt };
|
|
162
|
+
}
|
|
163
|
+
/** Marque une tentative dont l'issue externe ne peut être établie (réconciliation requise). */
|
|
164
|
+
export function markReceiptUnknown(doc, intentKey, reason, now) {
|
|
165
|
+
const receipt = doc.receipts.find((r) => r.intentKey === intentKey);
|
|
166
|
+
if (!receipt)
|
|
167
|
+
return;
|
|
168
|
+
receipt.status = "unknown";
|
|
169
|
+
receipt.unknownReason = reason;
|
|
170
|
+
receipt.updatedAt = now;
|
|
171
|
+
}
|
|
@@ -0,0 +1,59 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Admission durable et matrice de compatibilité (Plan 0002 §4/§6) : tant qu'une
|
|
3
|
+
* commande, un serveur MCP ou une extension n'est pas classé et testé, elle est
|
|
4
|
+
* INDISPONIBLE pour les missions durables. On bloque les presets non supportés
|
|
5
|
+
* au lieu d'élargir silencieusement l'accès (fail closed).
|
|
6
|
+
*
|
|
7
|
+
* La matrice publiée des profils supportés vit dans docs/durable-compatibility.md.
|
|
8
|
+
*/
|
|
9
|
+
import { assertMcpServerApproved, assertExtensionApproved, DEFAULT_APPROVED_COMMANDS, } from "../execution/egress.js";
|
|
10
|
+
export class DurableAdmissionError extends Error {
|
|
11
|
+
constructor(message) {
|
|
12
|
+
super(message);
|
|
13
|
+
this.name = "DurableAdmissionError";
|
|
14
|
+
}
|
|
15
|
+
}
|
|
16
|
+
function envList(env, key) {
|
|
17
|
+
return (env[key] ?? "").split(",").map((s) => s.trim()).filter(Boolean);
|
|
18
|
+
}
|
|
19
|
+
/**
|
|
20
|
+
* Registre toolchain pour les missions durables : défaut P2 (commandes de la
|
|
21
|
+
* toolchain approuvées, aucun MCP ni extension) + approbations explicites par
|
|
22
|
+
* l'environnement d'exploitation. Rien n'est approuvé implicitement.
|
|
23
|
+
*/
|
|
24
|
+
export function durableToolchainRegistry(env = process.env) {
|
|
25
|
+
const commands = new Set(DEFAULT_APPROVED_COMMANDS);
|
|
26
|
+
const mcps = new Set();
|
|
27
|
+
const extensions = new Set();
|
|
28
|
+
for (const name of envList(env, "COGITATOR_DURABLE_APPROVED_COMMANDS"))
|
|
29
|
+
commands.add(name);
|
|
30
|
+
for (const name of envList(env, "COGITATOR_DURABLE_APPROVED_MCPS"))
|
|
31
|
+
mcps.add(name);
|
|
32
|
+
for (const name of envList(env, "COGITATOR_DURABLE_APPROVED_EXTENSIONS"))
|
|
33
|
+
extensions.add(name);
|
|
34
|
+
return { approvedCommands: commands, approvedMcpServers: mcps, approvedExtensions: extensions };
|
|
35
|
+
}
|
|
36
|
+
/**
|
|
37
|
+
* Gate d'admission d'une mission durable : chaque serveur MCP déclaré dans le
|
|
38
|
+
* snapshot figé doit être classé. Sinon l'admission échoue et aucun travail
|
|
39
|
+
* caché n'est créé. (Les commandes se classent au niveau outil/CI, pas dans le
|
|
40
|
+
* snapshot spawn.)
|
|
41
|
+
*/
|
|
42
|
+
export function assertDurableAdmission(registry, spawn) {
|
|
43
|
+
try {
|
|
44
|
+
for (const server of spawn.mcpServers ?? [])
|
|
45
|
+
assertMcpServerApproved(registry, server.name);
|
|
46
|
+
}
|
|
47
|
+
catch (err) {
|
|
48
|
+
throw new DurableAdmissionError(`admission durable refusée (fail closed): ${err instanceof Error ? err.message : String(err)} — voir docs/durable-compatibility.md`);
|
|
49
|
+
}
|
|
50
|
+
}
|
|
51
|
+
/** Vérifie une capacité ponctuelle au nom de la runtime durable (extensions gelées). */
|
|
52
|
+
export function assertDurableExtension(registry, name) {
|
|
53
|
+
try {
|
|
54
|
+
assertExtensionApproved(registry, name);
|
|
55
|
+
}
|
|
56
|
+
catch (err) {
|
|
57
|
+
throw new DurableAdmissionError(err instanceof Error ? err.message : String(err));
|
|
58
|
+
}
|
|
59
|
+
}
|
|
@@ -0,0 +1,68 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Passerelle d'effets externes (Plan 0002 §5.4/§5.5, ADR-008 D6, S3) — le SEUL
|
|
3
|
+
* chemin autorisé pour un outil à effet externe :
|
|
4
|
+
*
|
|
5
|
+
* 1. Avant l'effet : consommation du grant et association de l'intent (clé
|
|
6
|
+
* d'idempotence persistée) dans UN commit atomique ; le scope exact
|
|
7
|
+
* (opération, cible, digests artefact/arguments immuables) est rechecké
|
|
8
|
+
* immédiatement avant l'effet ; sans grant valide, une action en attente est
|
|
9
|
+
* créée côté serveur et l'appel est bloqué (mission `waiting_approval`) ;
|
|
10
|
+
* 2. L'effet s'exécute ; l'issue OBSERVÉE côté distant est enregistrée en
|
|
11
|
+
* receipt — jamais inférée du texte du modèle ;
|
|
12
|
+
* 3. Reprise : une tentative déjà associée (même clé) avec issue observée n'est
|
|
13
|
+
* JAMAIS re-exécutée ; une tentative sans issue établie exige une
|
|
14
|
+
* réconciliation explicite (jamais de rejeu aveugle, Plan 0002 §5.4.4).
|
|
15
|
+
*/
|
|
16
|
+
import { MissionApprovals, GrantRejectedError, consumeGrantForEffect, createPendingAction, markReceiptUnknown, recordObservedReceipt, } from "./approvals.js";
|
|
17
|
+
/**
|
|
18
|
+
* Exécute `perform` sous autorisation de grant. `perform` doit réaliser
|
|
19
|
+
* l'effet et renvoyer l'issue observée (référence externe, code…).
|
|
20
|
+
*/
|
|
21
|
+
export async function runProtectedEffect(api, context, descriptor, intentKey, perform) {
|
|
22
|
+
const now = Date.now();
|
|
23
|
+
const decision = await api.commit(async (tx) => {
|
|
24
|
+
const doc = await tx.doc(MissionApprovals, api.conversationId);
|
|
25
|
+
const result = consumeGrantForEffect(doc, { ...descriptor, intentKey, taskId: api.taskId }, now);
|
|
26
|
+
if (result.kind === "rejected") {
|
|
27
|
+
// Pas de grant valide : le serveur crée l'action en attente (immumable) ;
|
|
28
|
+
// l'appel est bloqué, la mission passe visiblement en waiting_approval.
|
|
29
|
+
createPendingAction(doc, {
|
|
30
|
+
...descriptor,
|
|
31
|
+
consequence: descriptor.operation,
|
|
32
|
+
expiresAt: now + 24 * 60 * 60 * 1000,
|
|
33
|
+
allowedUses: 1,
|
|
34
|
+
}, now);
|
|
35
|
+
return { kind: "rejected", reason: result.reason };
|
|
36
|
+
}
|
|
37
|
+
if (result.kind === "duplicate")
|
|
38
|
+
return { kind: "duplicate", receipt: result.receipt };
|
|
39
|
+
return { kind: "consumed" };
|
|
40
|
+
}, context);
|
|
41
|
+
if (decision.kind === "rejected") {
|
|
42
|
+
throw new GrantRejectedError(`${decision.reason} — action en attente de décision owner`);
|
|
43
|
+
}
|
|
44
|
+
if (decision.kind === "duplicate") {
|
|
45
|
+
if (decision.receipt.status === "observed") {
|
|
46
|
+
// Tentative déjà réalisée et observée : la reprise renvoie l'issue connue.
|
|
47
|
+
return {
|
|
48
|
+
kind: "duplicate",
|
|
49
|
+
outcome: decision.receipt.observed?.outcome ?? "observé",
|
|
50
|
+
reference: decision.receipt.observed?.reference,
|
|
51
|
+
};
|
|
52
|
+
}
|
|
53
|
+
// Intent associé sans issue établie : réconciliation owner explicite.
|
|
54
|
+
throw new GrantRejectedError(`tentative ${intentKey} déjà associée sans issue établie : réconcilier l'issue externe avant toute reprise`);
|
|
55
|
+
}
|
|
56
|
+
let observed;
|
|
57
|
+
try {
|
|
58
|
+
observed = await perform();
|
|
59
|
+
}
|
|
60
|
+
catch (err) {
|
|
61
|
+
// L'issue externe est inconnue : on la conserve comme telle (jamais de
|
|
62
|
+
// rejeu implicite) et on propage l'échec à l'outil.
|
|
63
|
+
await api.commit((tx) => tx.doc(MissionApprovals, api.conversationId).then((doc) => markReceiptUnknown(doc, intentKey, err instanceof Error ? err.message : String(err), Date.now())), context);
|
|
64
|
+
throw err;
|
|
65
|
+
}
|
|
66
|
+
await api.commit((tx) => tx.doc(MissionApprovals, api.conversationId).then((doc) => recordObservedReceipt(doc, intentKey, observed, Date.now())), context);
|
|
67
|
+
return { kind: "performed" };
|
|
68
|
+
}
|
|
@@ -0,0 +1,48 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Bail d'exécution (runtime lease, Plan 0002 §5 « Runtime lease » + §8
|
|
3
|
+
* « Recovery ») : propriété OS-exclusive du stockage Durable par UN processus.
|
|
4
|
+
*
|
|
5
|
+
* Le SDK Durable n'a pas de bail inter-processus (constat P0) : on l'impose
|
|
6
|
+
* ici avec `locking_mode = EXCLUSIVE` de SQLite (verrou de fichier OS via
|
|
7
|
+
* better-sqlite3, déjà dépendance du contrôleur). Le second processus qui
|
|
8
|
+
* ouvre la même base de bail obtient SQLITE_BUSY et sort SANS planifier quoi
|
|
9
|
+
* que ce soit ; la mort du détenteur (SIGKILL inclus) libère le verrou côté OS.
|
|
10
|
+
*/
|
|
11
|
+
import Database from "better-sqlite3";
|
|
12
|
+
import { mkdirSync } from "node:fs";
|
|
13
|
+
import { join } from "node:path";
|
|
14
|
+
export class RuntimeLeaseError extends Error {
|
|
15
|
+
constructor(message = "bail d'exécution déjà détenu par un autre processus") {
|
|
16
|
+
super(message);
|
|
17
|
+
this.name = "RuntimeLeaseError";
|
|
18
|
+
}
|
|
19
|
+
}
|
|
20
|
+
export function acquireRuntimeLease(dir) {
|
|
21
|
+
mkdirSync(dir, { recursive: true });
|
|
22
|
+
const path = join(dir, "lease.sqlite");
|
|
23
|
+
const db = new Database(path);
|
|
24
|
+
try {
|
|
25
|
+
db.pragma("locking_mode = EXCLUSIVE");
|
|
26
|
+
// Première instruction : prend le verrou EXCLUSIVE ; SQLITE_BUSY si un
|
|
27
|
+
// autre processus détient déjà le bail. Pas de busy_timeout : échec net.
|
|
28
|
+
db.exec("CREATE TABLE IF NOT EXISTS runtime_lease (id INTEGER PRIMARY KEY CHECK (id = 1), pid INTEGER NOT NULL, acquired_at TEXT NOT NULL)");
|
|
29
|
+
db.prepare("INSERT OR REPLACE INTO runtime_lease (id, pid, acquired_at) VALUES (1, ?, datetime('now'))").run(process.pid);
|
|
30
|
+
}
|
|
31
|
+
catch (err) {
|
|
32
|
+
db.close();
|
|
33
|
+
if (err instanceof Error && "code" in err && err.code === "SQLITE_BUSY")
|
|
34
|
+
throw new RuntimeLeaseError();
|
|
35
|
+
throw err;
|
|
36
|
+
}
|
|
37
|
+
return {
|
|
38
|
+
path,
|
|
39
|
+
release: () => {
|
|
40
|
+
try {
|
|
41
|
+
db.close();
|
|
42
|
+
}
|
|
43
|
+
catch {
|
|
44
|
+
/* déjà fermé */
|
|
45
|
+
}
|
|
46
|
+
},
|
|
47
|
+
};
|
|
48
|
+
}
|
|
@@ -0,0 +1,167 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Gestionnaire des runtimes durables (point de composition `src/runtime.ts`) :
|
|
3
|
+
* une runtime ouverte par conversation durable, dans le processus contrôleur,
|
|
4
|
+
* avec bail OS sur son stockage. Le catalogue ne garde que la référence (D4) ;
|
|
5
|
+
* la vérité de mission (transcripts, checkpoints, profil gelé, approbations,
|
|
6
|
+
* file d'admission, budget) vit dans le stockage Durable propre à la
|
|
7
|
+
* conversation, sous `<home>/durable/<convId>/`.
|
|
8
|
+
*
|
|
9
|
+
* Le gestionnaire détient aussi le plan de contrôle d'admission PARTAGÉ
|
|
10
|
+
* (ticket #16) : deux slots d'exécution (D7) et les claims workspace exclusifs
|
|
11
|
+
* — une mission n'est dispatchée que si elle obtient les deux, sinon sa file
|
|
12
|
+
* reste visible. Les états de mission sont re-projetés sur un EventEmitter que
|
|
13
|
+
* le serveur branche sur le SSE de la conversation.
|
|
14
|
+
*/
|
|
15
|
+
import { EventEmitter } from "node:events";
|
|
16
|
+
import { piAiProviders } from "../host-pi.js";
|
|
17
|
+
import { createRegistry } from "@earendil-works/pi-durable";
|
|
18
|
+
import { homedir } from "node:os";
|
|
19
|
+
import { join } from "node:path";
|
|
20
|
+
import { DurableMissionRuntime } from "./mission-runtime.js";
|
|
21
|
+
import { MissionSlotPool, WorkspaceClaims } from "./admission.js";
|
|
22
|
+
import { digest } from "./profile.js";
|
|
23
|
+
export class DurableRuntimeManager {
|
|
24
|
+
opts;
|
|
25
|
+
open = new Map();
|
|
26
|
+
slots;
|
|
27
|
+
claims = new WorkspaceClaims();
|
|
28
|
+
emitter = new EventEmitter();
|
|
29
|
+
now;
|
|
30
|
+
/** Rappel UTC : à minuit, les gates quotidiens se délient et la file re-filtre. */
|
|
31
|
+
utcTimer;
|
|
32
|
+
constructor(opts) {
|
|
33
|
+
this.opts = opts;
|
|
34
|
+
this.slots = new MissionSlotPool(opts.missionSlots ?? 2);
|
|
35
|
+
this.now = opts.now ?? Date.now;
|
|
36
|
+
this.utcTimer = setInterval(() => void this.requeueAll(), 60_000);
|
|
37
|
+
this.utcTimer.unref();
|
|
38
|
+
}
|
|
39
|
+
dirFor(convId) {
|
|
40
|
+
return join(this.opts.paths.home, "durable", convId);
|
|
41
|
+
}
|
|
42
|
+
/** Ouvre (ou réouvre après fermeture) la runtime durable d'une conversation. */
|
|
43
|
+
async get(conv) {
|
|
44
|
+
const managed = this.open.get(conv.id);
|
|
45
|
+
if (managed && !managed.closed)
|
|
46
|
+
return managed.runtime;
|
|
47
|
+
const spawn = JSON.parse(conv.spawn_args || "{}");
|
|
48
|
+
const workspaceDir = conv.workspace_dir ?? homedir();
|
|
49
|
+
const slots = this.slots;
|
|
50
|
+
const claims = this.claims;
|
|
51
|
+
const emit = (state) => {
|
|
52
|
+
this.emitter.emit(conv.id, state);
|
|
53
|
+
};
|
|
54
|
+
const requeue = () => void this.requeueAll();
|
|
55
|
+
const openRuntimes = this.open;
|
|
56
|
+
const control = {
|
|
57
|
+
workspaceDir,
|
|
58
|
+
tryAdmit() {
|
|
59
|
+
const claim = claims.acquire(workspaceDir, conv.id);
|
|
60
|
+
if (!claim.claimed)
|
|
61
|
+
return { admitted: false, reason: `workspace_claimed_par:${claim.heldBy}` };
|
|
62
|
+
const slot = slots.tryAcquire(conv.id);
|
|
63
|
+
if (!slot.admitted) {
|
|
64
|
+
claims.release(workspaceDir, conv.id);
|
|
65
|
+
return { admitted: false, reason: slot.reason ?? "slots_missions_pleins" };
|
|
66
|
+
}
|
|
67
|
+
return { admitted: true };
|
|
68
|
+
},
|
|
69
|
+
release() {
|
|
70
|
+
claims.release(workspaceDir, conv.id);
|
|
71
|
+
const promoted = slots.release(conv.id);
|
|
72
|
+
// La mission promue dispatche SA file immédiatement ; les autres en
|
|
73
|
+
// file re-tentent ensuite leur admission (un slot vient de se libérer).
|
|
74
|
+
if (promoted) {
|
|
75
|
+
const managed = openRuntimes.get(promoted);
|
|
76
|
+
if (managed && !managed.closed)
|
|
77
|
+
void managed.runtime.tryDrainQueue();
|
|
78
|
+
}
|
|
79
|
+
requeue();
|
|
80
|
+
},
|
|
81
|
+
claimHolder() {
|
|
82
|
+
return claims.holder(workspaceDir);
|
|
83
|
+
},
|
|
84
|
+
emit,
|
|
85
|
+
};
|
|
86
|
+
const runtime = await DurableMissionRuntime.open({
|
|
87
|
+
dir: this.dirFor(conv.id),
|
|
88
|
+
cwd: workspaceDir,
|
|
89
|
+
model: { provider: spawn.provider ?? conv.provider, modelId: spawn.model ?? conv.model },
|
|
90
|
+
presetDigest: digest(conv.spawn_args || "{}"),
|
|
91
|
+
models: (this.opts.modelsFactory ?? (() => piAiProviders.builtinModels()))(),
|
|
92
|
+
registry: (this.opts.registryFactory ?? (() => createRegistry()))(),
|
|
93
|
+
agentExtensions: this.opts.agentExtensions ?? [],
|
|
94
|
+
toolchain: {
|
|
95
|
+
commands: [...this.opts.toolchain.approvedCommands],
|
|
96
|
+
mcpServers: [...this.opts.toolchain.approvedMcpServers],
|
|
97
|
+
},
|
|
98
|
+
control,
|
|
99
|
+
});
|
|
100
|
+
const entry = { runtime, closed: false };
|
|
101
|
+
this.open.set(conv.id, entry);
|
|
102
|
+
return runtime;
|
|
103
|
+
}
|
|
104
|
+
/** Projection de statut de mission (ouvre la runtime durable si besoin). */
|
|
105
|
+
async missionStatus(conv) {
|
|
106
|
+
const runtime = await this.get(conv);
|
|
107
|
+
return runtime.missionStatus(this.now());
|
|
108
|
+
}
|
|
109
|
+
/** Abonnement aux changements d'état d'une mission (fan-out SSE serveur). */
|
|
110
|
+
onMissionState(convId, listener) {
|
|
111
|
+
this.emitter.on(convId, listener);
|
|
112
|
+
return () => this.emitter.off(convId, listener);
|
|
113
|
+
}
|
|
114
|
+
/** Détail d'admission pour les tests et l'observabilité. */
|
|
115
|
+
admissionSnapshot() {
|
|
116
|
+
return {
|
|
117
|
+
running: this.slots.running,
|
|
118
|
+
queued: this.slots.queued,
|
|
119
|
+
claims: this.claims.entries(),
|
|
120
|
+
};
|
|
121
|
+
}
|
|
122
|
+
/**
|
|
123
|
+
* Fait re-tenter l'admission à toutes les missions ayant une file (file
|
|
124
|
+
* d'inputs, pas seulement la file de slots : une mission peut être retenue
|
|
125
|
+
* par le claim workspace sans jamais avoir rejoint la file de slots).
|
|
126
|
+
*/
|
|
127
|
+
async requeueAll() {
|
|
128
|
+
// Les runtimes déjà fermées lâchent d'abord leur place éventuelle.
|
|
129
|
+
for (const missionId of this.slots.queued) {
|
|
130
|
+
const managed = this.open.get(missionId);
|
|
131
|
+
if (!managed || managed.closed)
|
|
132
|
+
this.slots.release(missionId);
|
|
133
|
+
}
|
|
134
|
+
for (const managed of this.open.values()) {
|
|
135
|
+
if (!managed.closed)
|
|
136
|
+
await managed.runtime.tryDrainQueue();
|
|
137
|
+
}
|
|
138
|
+
}
|
|
139
|
+
/** Runtime déjà ouverte dans ce processus (sans ouvrir) — lecture SSE sans créer de mission. */
|
|
140
|
+
getIfOpen(convId) {
|
|
141
|
+
const managed = this.open.get(convId);
|
|
142
|
+
return managed && !managed.closed ? managed.runtime : undefined;
|
|
143
|
+
}
|
|
144
|
+
/** Ferme la runtime d'une conversation (le stockage Durable, lui, survit). */
|
|
145
|
+
async release(convId) {
|
|
146
|
+
const managed = this.open.get(convId);
|
|
147
|
+
this.open.delete(convId);
|
|
148
|
+
if (managed && !managed.closed) {
|
|
149
|
+
managed.closed = true;
|
|
150
|
+
await managed.runtime.close();
|
|
151
|
+
}
|
|
152
|
+
// La fermeture relâche aussi slot et claim détenus (sinon fuite d'admission).
|
|
153
|
+
this.claims.releaseByMission(convId);
|
|
154
|
+
const promoted = this.slots.release(convId);
|
|
155
|
+
if (promoted) {
|
|
156
|
+
const next = this.open.get(promoted);
|
|
157
|
+
if (next && !next.closed)
|
|
158
|
+
void next.runtime.tryDrainQueue();
|
|
159
|
+
}
|
|
160
|
+
void this.requeueAll();
|
|
161
|
+
}
|
|
162
|
+
async dispose() {
|
|
163
|
+
clearInterval(this.utcTimer);
|
|
164
|
+
for (const convId of [...this.open.keys()])
|
|
165
|
+
await this.release(convId);
|
|
166
|
+
}
|
|
167
|
+
}
|