@ignitionai/cogitator 0.4.0 → 0.5.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +30 -8
- package/dist/extensions/index.js +1 -1
- package/dist/src/classic-configuration.js +153 -0
- 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/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 +4 -1
- package/web/dist/assets/index-C3tRuOTh.js +83 -0
- package/web/dist/assets/index-DMQqB0r1.css +1 -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,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 { builtinModels } from "@earendil-works/pi-ai/providers/all";
|
|
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 ?? (() => 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
|
+
}
|