@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,108 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Confinement de chemins pour l'exécution distante (Plan 0002 §4, phase P2).
|
|
3
|
+
*
|
|
4
|
+
* Résolution realpath avec rejet des échappées par symlink sur lectures,
|
|
5
|
+
* écritures, imports et enrôlement de workspaces. Le montage conteneur reste
|
|
6
|
+
* la containment primaire (ADR-008 D5) ; ces vérifications sont la défense en
|
|
7
|
+
* profondeur — un TOCTOU entre la vérification et l'ouverture côté hôte reste
|
|
8
|
+
* possible, d'où l'obligation du worker rootless en conteneur pour les missions
|
|
9
|
+
* distantes.
|
|
10
|
+
*/
|
|
11
|
+
import { existsSync, realpathSync } from "node:fs";
|
|
12
|
+
import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
|
|
13
|
+
import { authenticationRequired } from "../config.js";
|
|
14
|
+
function isInside(path, root) {
|
|
15
|
+
return path === root || path.startsWith(root + sep);
|
|
16
|
+
}
|
|
17
|
+
/**
|
|
18
|
+
* Résout `requested` de façon canonique et garantit qu'il reste sous la racine
|
|
19
|
+
* réelle (après résolution des symlinks). Un symlink intermédiaire pointant
|
|
20
|
+
* hors de la racine est rejeté, y compris pour un fichier qui n'existe pas
|
|
21
|
+
* encore (écriture) : on canonicalise le plus long préfixe existant puis on
|
|
22
|
+
* résout le reste lexicalement.
|
|
23
|
+
*/
|
|
24
|
+
export function resolveConfined(rootDir, requested) {
|
|
25
|
+
let root;
|
|
26
|
+
try {
|
|
27
|
+
root = realpathSync(resolve(rootDir));
|
|
28
|
+
}
|
|
29
|
+
catch {
|
|
30
|
+
return { error: `racine illisible: ${rootDir}` };
|
|
31
|
+
}
|
|
32
|
+
const target = isAbsolute(requested) ? resolve(requested) : resolve(root, requested);
|
|
33
|
+
let existing = target;
|
|
34
|
+
const tail = [];
|
|
35
|
+
while (!existsSync(existing)) {
|
|
36
|
+
const parent = dirname(existing);
|
|
37
|
+
if (parent === existing)
|
|
38
|
+
return { error: "chemin hors du workspace" };
|
|
39
|
+
tail.unshift(basename(existing));
|
|
40
|
+
existing = parent;
|
|
41
|
+
}
|
|
42
|
+
let base;
|
|
43
|
+
try {
|
|
44
|
+
base = realpathSync(existing);
|
|
45
|
+
}
|
|
46
|
+
catch {
|
|
47
|
+
return { error: "chemin hors du workspace" };
|
|
48
|
+
}
|
|
49
|
+
const path = join(base, ...tail);
|
|
50
|
+
if (!isInside(path, root))
|
|
51
|
+
return { error: "chemin hors du workspace" };
|
|
52
|
+
return { path };
|
|
53
|
+
}
|
|
54
|
+
function enrolledDir(policy, requested) {
|
|
55
|
+
const target = resolve(requested);
|
|
56
|
+
// Casse /var → /private/var (macOS) et liens au-dessus de la racine : comparer
|
|
57
|
+
// les formes canoniques des deux côtés, tout en détectant les symlinks sortants.
|
|
58
|
+
let canonical = null;
|
|
59
|
+
try {
|
|
60
|
+
canonical = realpathSync(target);
|
|
61
|
+
}
|
|
62
|
+
catch {
|
|
63
|
+
/* dossier inexistant : refusé par l'appelant avant l'enrôlement */
|
|
64
|
+
}
|
|
65
|
+
for (const enrolled of policy.enrolledRoots) {
|
|
66
|
+
let root;
|
|
67
|
+
try {
|
|
68
|
+
root = realpathSync(resolve(enrolled));
|
|
69
|
+
}
|
|
70
|
+
catch {
|
|
71
|
+
continue; // racine enrôlée absente : on essaye les autres
|
|
72
|
+
}
|
|
73
|
+
const lexInside = isInside(target, resolve(enrolled));
|
|
74
|
+
const canonInside = canonical !== null && isInside(canonical, root);
|
|
75
|
+
if (!lexInside && !canonInside)
|
|
76
|
+
continue;
|
|
77
|
+
if (!canonInside)
|
|
78
|
+
return { error: "enrôlement refusé: symlink hors de la racine enrôlée" };
|
|
79
|
+
const confined = resolveConfined(root, target);
|
|
80
|
+
if ("error" in confined)
|
|
81
|
+
return { error: "enrôlement refusé: symlink hors de la racine enrôlée" };
|
|
82
|
+
return { dir: confined.path };
|
|
83
|
+
}
|
|
84
|
+
return { error: "enrôlement de dossier arbitraire désactivé en mode distant (hors racines enrôlées)" };
|
|
85
|
+
}
|
|
86
|
+
/**
|
|
87
|
+
* Enrôlement d'un dossier de travail. Mode distant : seuls les dossiers sous
|
|
88
|
+
* une racine enrôlée sont acceptés et un symlink qui déplace le dossier hors
|
|
89
|
+
* de sa racine est rejeté (Plan 0002 §4 : l'enrôlement ne rend pas le dossier
|
|
90
|
+
* original jetable). Mode local : comportement historique (canonicalisation).
|
|
91
|
+
*/
|
|
92
|
+
export function enrollWorkspaceDir(policy, requested) {
|
|
93
|
+
if (policy.remote)
|
|
94
|
+
return enrolledDir(policy, requested);
|
|
95
|
+
try {
|
|
96
|
+
return { dir: realpathSync(requested) };
|
|
97
|
+
}
|
|
98
|
+
catch {
|
|
99
|
+
return { error: `dossier illisible: ${requested}` };
|
|
100
|
+
}
|
|
101
|
+
}
|
|
102
|
+
/** Politique d'enrôlement depuis l'environnement (mode distant = authentification requise, fail-closed). */
|
|
103
|
+
export function enrollmentPolicyFromEnv(env = process.env) {
|
|
104
|
+
return {
|
|
105
|
+
remote: authenticationRequired(env),
|
|
106
|
+
enrolledRoots: (env.COGITATOR_ENROLLED_ROOTS ?? "").split(":").map((p) => p.trim()).filter(Boolean),
|
|
107
|
+
};
|
|
108
|
+
}
|
|
@@ -0,0 +1,102 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Spécification des workers conteneurisés (Plan 0002 §4, P2 ; ADR-008 D5).
|
|
3
|
+
*
|
|
4
|
+
* Construction pure et vérifiable d'un `docker run` orienté rootless :
|
|
5
|
+
* rootfs en lecture seule, scratch tmpfs noexec, seul le workspace enrôlé est
|
|
6
|
+
* monté (rw), aucun socket Docker ni montage du plan de contrôle, capabilities
|
|
7
|
+
* droppées, métadonnées cloud et ports du plan de contrôle injoignables
|
|
8
|
+
* (network none par défaut ; egress uniquement via le proxy allowlist), limites
|
|
9
|
+
* mémoire/CPU/PID, utilisateur non-root, aucun secret dans l'environnement.
|
|
10
|
+
*
|
|
11
|
+
* Limite documentée : le Docker local de développement n'est pas une preuve
|
|
12
|
+
* rootless de production ; l'application rejetée ici (spec invalide) et les
|
|
13
|
+
* limites non supportées par l'hôte (validateHostEnforcement) sont des échecs
|
|
14
|
+
* de déploiement, jamais un abaissement silencieux.
|
|
15
|
+
*/
|
|
16
|
+
import { enrollWorkspaceDir } from "./confinement.js";
|
|
17
|
+
import { egressProxyEnv } from "./egress.js";
|
|
18
|
+
import { resolve, sep } from "node:path";
|
|
19
|
+
const FORBIDDEN_MOUNT_SOURCES = ["/var/run/docker.sock", "/run/docker.sock", "/var/run/docker"];
|
|
20
|
+
/** Le worker ne reçoit aucun secret : clés fournisseurs, tokens GitHub, état Cogitator. */
|
|
21
|
+
const SECRET_ENV_PATTERN = /^(AWS_|AZURE_|GOOGLE_|GITHUB_|GH_|OPENAI_|ANTHROPIC_|COGITATOR_|SECRET|TOKEN)/i;
|
|
22
|
+
function isForbiddenMount(source) {
|
|
23
|
+
const canonical = resolve(source);
|
|
24
|
+
return FORBIDDEN_MOUNT_SOURCES.some((f) => canonical === resolve(f) || canonical.endsWith(sep + "docker.sock"));
|
|
25
|
+
}
|
|
26
|
+
/** IP de métadonnées cloud (169.254.169.254) — injoignable avec network "none". */
|
|
27
|
+
export const CLOUD_METADATA_IP = "169.254.169.254";
|
|
28
|
+
export function buildWorkerContainerSpec(input, enrollment) {
|
|
29
|
+
if (input.workspaceMount) {
|
|
30
|
+
const enrolled = enrollWorkspaceDir(enrollment, input.workspaceMount.source);
|
|
31
|
+
if ("error" in enrolled)
|
|
32
|
+
return { error: `montage workspace refusé: ${enrolled.error}` };
|
|
33
|
+
const source = enrolled.dir;
|
|
34
|
+
if (isForbiddenMount(source)) {
|
|
35
|
+
return { error: `montage du plan de contrôle refusé: ${source}` };
|
|
36
|
+
}
|
|
37
|
+
input = { ...input, workspaceMount: { ...input.workspaceMount, source } };
|
|
38
|
+
}
|
|
39
|
+
for (const [key, value] of Object.entries(input.env ?? {})) {
|
|
40
|
+
if (SECRET_ENV_PATTERN.test(key))
|
|
41
|
+
return { error: `variable d'environnement secrète refusée au worker: ${key}` };
|
|
42
|
+
if (value.includes(CLOUD_METADATA_IP))
|
|
43
|
+
return { error: `valeur d'environnement pointant vers les métadonnées cloud: ${key}` };
|
|
44
|
+
}
|
|
45
|
+
let env = { ...(input.env ?? {}) };
|
|
46
|
+
const network = input.egress ? "egress" : "none";
|
|
47
|
+
if (input.egress)
|
|
48
|
+
env = { ...env, ...egressProxyEnv(input.egress) };
|
|
49
|
+
return {
|
|
50
|
+
spec: {
|
|
51
|
+
image: input.image,
|
|
52
|
+
name: input.name,
|
|
53
|
+
command: input.command,
|
|
54
|
+
mounts: input.workspaceMount
|
|
55
|
+
? [{ source: input.workspaceMount.source, target: input.workspaceMount.target, readOnly: false }]
|
|
56
|
+
: [],
|
|
57
|
+
network,
|
|
58
|
+
env,
|
|
59
|
+
user: input.user ?? "65534:65534", // nobody:nogroup — jamais root
|
|
60
|
+
memoryBytes: input.memoryBytes ?? 2 * 1024 ** 3, // 2 GiB (Plan 0002, worker limits)
|
|
61
|
+
cpuCount: input.cpuCount ?? 1.5,
|
|
62
|
+
pidsLimit: input.pidsLimit ?? 256,
|
|
63
|
+
},
|
|
64
|
+
};
|
|
65
|
+
}
|
|
66
|
+
/** Traduction en arguments `docker run` (image linux/OCI, Docker comme chemin local d'expérimentation). */
|
|
67
|
+
export function dockerRunArgs(spec) {
|
|
68
|
+
const args = [
|
|
69
|
+
"run", "--rm", "-i",
|
|
70
|
+
"--name", spec.name,
|
|
71
|
+
"--read-only",
|
|
72
|
+
"--tmpfs", "/tmp:rw,noexec,nosuid,size=256m",
|
|
73
|
+
"--tmpfs", "/workspace/.scratch:rw,noexec,nosuid,size=256m,mode=1777",
|
|
74
|
+
"--cap-drop", "ALL",
|
|
75
|
+
"--security-opt", "no-new-privileges",
|
|
76
|
+
"--user", spec.user,
|
|
77
|
+
"--network", spec.network === "none" ? "none" : "bridge",
|
|
78
|
+
"--memory", String(spec.memoryBytes),
|
|
79
|
+
"--cpus", String(spec.cpuCount),
|
|
80
|
+
"--pids-limit", String(spec.pidsLimit),
|
|
81
|
+
];
|
|
82
|
+
for (const mount of spec.mounts) {
|
|
83
|
+
args.push("-v", `${mount.source}:${mount.target}${mount.readOnly ? ":ro" : ":rw"}`);
|
|
84
|
+
}
|
|
85
|
+
for (const [key, value] of Object.entries(spec.env)) {
|
|
86
|
+
args.push("--env", `${key}=${value}`);
|
|
87
|
+
}
|
|
88
|
+
args.push(spec.image, ...spec.command);
|
|
89
|
+
return args;
|
|
90
|
+
}
|
|
91
|
+
/**
|
|
92
|
+
* Une limite ressource non supportée par l'hôte est un échec de déploiement
|
|
93
|
+
* (Plan 0002 §8 : pas d'abaissement silencieux). Seccomp obligatoire.
|
|
94
|
+
*/
|
|
95
|
+
export function validateHostEnforcement(info) {
|
|
96
|
+
if (!info.securityOptions.some((o) => o.includes("seccomp"))) {
|
|
97
|
+
throw new Error("déploiement refusé: seccomp non actif sur l'hôte Docker");
|
|
98
|
+
}
|
|
99
|
+
if (!info.cgroupDriver) {
|
|
100
|
+
throw new Error("déploiement refusé: driver cgroup indéterminé, limites mémoire/CPU non garanties");
|
|
101
|
+
}
|
|
102
|
+
}
|
|
@@ -0,0 +1,69 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Egress default-deny et classification des capacités (Plan 0002 §4, P2).
|
|
3
|
+
*
|
|
4
|
+
* Les workers n'atteignent que les destinations approuvées de la toolchain,
|
|
5
|
+
* par un chemin contrôlé (proxy allowlist imposé par env). Les commandes,
|
|
6
|
+
* serveurs MCP et extensions non classifiés sont indisponibles aux missions
|
|
7
|
+
* distantes : tant qu'une capacité n'est pas classée et testée, elle n'existe
|
|
8
|
+
* pas en mode distant.
|
|
9
|
+
*/
|
|
10
|
+
/** Destinations initiales approuvées pour la toolchain (registre npm + GitHub). */
|
|
11
|
+
export const DEFAULT_APPROVED_DESTINATIONS = [
|
|
12
|
+
"registry.npmjs.org",
|
|
13
|
+
"github.com",
|
|
14
|
+
"api.github.com",
|
|
15
|
+
"codeload.github.com",
|
|
16
|
+
];
|
|
17
|
+
export class EgressDeniedError extends Error {
|
|
18
|
+
}
|
|
19
|
+
/** Default-deny : lève une erreur sauf si l'hôte est explicitement approuvé. */
|
|
20
|
+
export function assertEgressAllowed(policy, host) {
|
|
21
|
+
const clean = host.trim().toLowerCase().replace(/:\d+$/, "");
|
|
22
|
+
if (!policy.allowedHosts.includes(clean)) {
|
|
23
|
+
throw new EgressDeniedError(`egress refusé (default-deny): ${host}`);
|
|
24
|
+
}
|
|
25
|
+
}
|
|
26
|
+
/**
|
|
27
|
+
* Variables d'environnement imposées au worker : tout le trafic sortant passe
|
|
28
|
+
* par le chemin contrôlé. Aucun contournement NO_PROXY n'est laissé au worker.
|
|
29
|
+
*/
|
|
30
|
+
export function egressProxyEnv(policy) {
|
|
31
|
+
if (!policy.proxy)
|
|
32
|
+
throw new Error("egress: chemin contrôlé (proxy allowlist) non configuré");
|
|
33
|
+
return {
|
|
34
|
+
HTTP_PROXY: policy.proxy,
|
|
35
|
+
HTTPS_PROXY: policy.proxy,
|
|
36
|
+
http_proxy: policy.proxy,
|
|
37
|
+
https_proxy: policy.proxy,
|
|
38
|
+
NO_PROXY: "",
|
|
39
|
+
no_proxy: "",
|
|
40
|
+
};
|
|
41
|
+
}
|
|
42
|
+
/** Commandes de la toolchain initialement classées et testées (profil P0). */
|
|
43
|
+
export const DEFAULT_APPROVED_COMMANDS = ["node", "npm", "npx", "pnpm", "git", "tsc"];
|
|
44
|
+
export function defaultToolchainRegistry() {
|
|
45
|
+
return {
|
|
46
|
+
approvedCommands: new Set(DEFAULT_APPROVED_COMMANDS),
|
|
47
|
+
approvedMcpServers: new Set(),
|
|
48
|
+
approvedExtensions: new Set(),
|
|
49
|
+
};
|
|
50
|
+
}
|
|
51
|
+
export class UnclassifiedCapabilityError extends Error {
|
|
52
|
+
}
|
|
53
|
+
function assertClassified(approved, kind, name) {
|
|
54
|
+
if (!approved.has(name)) {
|
|
55
|
+
throw new UnclassifiedCapabilityError(`${kind} non classé, indisponible en mode distant: ${name}`);
|
|
56
|
+
}
|
|
57
|
+
}
|
|
58
|
+
/** Commande non classée → indisponible aux missions distantes. */
|
|
59
|
+
export function assertCommandApproved(registry, command) {
|
|
60
|
+
assertClassified(registry.approvedCommands, "commande", command);
|
|
61
|
+
}
|
|
62
|
+
/** Serveur MCP non classé → indisponible aux missions distantes. */
|
|
63
|
+
export function assertMcpServerApproved(registry, name) {
|
|
64
|
+
assertClassified(registry.approvedMcpServers, "serveur MCP", name);
|
|
65
|
+
}
|
|
66
|
+
/** Extension non classée → indisponible aux missions distantes. */
|
|
67
|
+
export function assertExtensionApproved(registry, name) {
|
|
68
|
+
assertClassified(registry.approvedExtensions, "extension", name);
|
|
69
|
+
}
|
|
@@ -0,0 +1,71 @@
|
|
|
1
|
+
import { randomUUID } from "node:crypto";
|
|
2
|
+
/** Taille d'un groupe (verrou produit, plan 0004 : 2–6 bots). */
|
|
3
|
+
export const GROUP_MIN = 2;
|
|
4
|
+
export const GROUP_MAX = 6;
|
|
5
|
+
export function getGroup(db, id) {
|
|
6
|
+
const row = db.prepare("SELECT * FROM agent_group WHERE id = ?").get(id);
|
|
7
|
+
return row ?? null;
|
|
8
|
+
}
|
|
9
|
+
export function listGroupMembers(db, groupId) {
|
|
10
|
+
const rows = db
|
|
11
|
+
.prepare(`SELECT c.agent_id, p.name, p.slug, c.provider, c.model, c.thinking, c.runtime_kind, c.pending_configuration, c.id AS conversation_id,
|
|
12
|
+
(g.host_agent_id = c.agent_id) AS is_host
|
|
13
|
+
FROM conversation c
|
|
14
|
+
JOIN agent_preset p ON p.id = c.agent_id
|
|
15
|
+
JOIN agent_group g ON g.id = c.group_id
|
|
16
|
+
WHERE c.group_id = ?
|
|
17
|
+
ORDER BY c.created_at`)
|
|
18
|
+
.all(groupId);
|
|
19
|
+
return rows.map(row => ({ ...row, pending_configuration: typeof row.pending_configuration === "string" ? JSON.parse(row.pending_configuration) : null }));
|
|
20
|
+
}
|
|
21
|
+
export function listGroups(db) {
|
|
22
|
+
const rows = db.prepare("SELECT * FROM agent_group ORDER BY updated_at DESC").all();
|
|
23
|
+
return rows.map((g) => ({ ...g, members: listGroupMembers(db, g.id) }));
|
|
24
|
+
}
|
|
25
|
+
export function getGroupWithMembers(db, id) {
|
|
26
|
+
const row = getGroup(db, id);
|
|
27
|
+
return row ? { ...row, members: listGroupMembers(db, id) } : null;
|
|
28
|
+
}
|
|
29
|
+
/** Insère le groupe ; les conversations membres sont créées par l'appelant (server) via createConversation. */
|
|
30
|
+
export function insertGroup(db, input) {
|
|
31
|
+
const id = randomUUID();
|
|
32
|
+
db.prepare("INSERT INTO agent_group (id, name, host_agent_id, default_workspace_id) VALUES (?, ?, ?, ?)").run(id, input.name, input.hostAgentId, input.defaultWorkspaceId ?? null);
|
|
33
|
+
return getGroup(db, id);
|
|
34
|
+
}
|
|
35
|
+
export function deleteGroup(db, id) {
|
|
36
|
+
return db.prepare("DELETE FROM agent_group WHERE id = ?").run(id).changes > 0;
|
|
37
|
+
}
|
|
38
|
+
export function appendGroupMessage(db, input) {
|
|
39
|
+
const id = randomUUID();
|
|
40
|
+
db.prepare(`INSERT INTO group_message (id, group_id, conversation_id, agent_id, role, text, detail, is_error)
|
|
41
|
+
VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.groupId, input.conversationId ?? null, input.agentId ?? null, input.role, input.text, input.detail ?? null, input.isError ? 1 : 0);
|
|
42
|
+
return db.prepare("SELECT * FROM group_message WHERE id = ?").get(id);
|
|
43
|
+
}
|
|
44
|
+
const GROUP_MESSAGES_LIMIT = 300;
|
|
45
|
+
export function listGroupMessages(db, groupId, limit = GROUP_MESSAGES_LIMIT) {
|
|
46
|
+
return db
|
|
47
|
+
.prepare("SELECT * FROM group_message WHERE group_id = ? ORDER BY created_at, rowid LIMIT ?")
|
|
48
|
+
.all(groupId, limit);
|
|
49
|
+
}
|
|
50
|
+
/** Première mention @nom/@slug qui correspond à un membre, ou null si aucune ne correspond. */
|
|
51
|
+
export function matchGroupMention(group, text) {
|
|
52
|
+
const mention = text.match(/(?:^|\s)@([A-Za-z0-9][A-Za-z0-9_-]*)/);
|
|
53
|
+
if (!mention)
|
|
54
|
+
return null;
|
|
55
|
+
const token = mention[1].toLowerCase();
|
|
56
|
+
return group.members.find((m) => m.name.toLowerCase() === token || m.slug.toLowerCase() === token) ?? null;
|
|
57
|
+
}
|
|
58
|
+
/** Routage ADR-011 : la première mention @nom/@slug d'un membre le vise ; sinon l'hôte répond. */
|
|
59
|
+
export function routeGroupMessage(group, text) {
|
|
60
|
+
// ponytail: une seule mention visée par ligne ; mentions parallèles = ticket dédié
|
|
61
|
+
return matchGroupMention(group, text) ?? group.members.find((m) => m.is_host === 1);
|
|
62
|
+
}
|
|
63
|
+
/** Propriétaire groupe d'une conversation membre (fan-out bus), ou null pour un fil 1–1. */
|
|
64
|
+
export function conversationGroupOwner(db, conversationId) {
|
|
65
|
+
const row = db
|
|
66
|
+
.prepare(`SELECT c.group_id, c.agent_id, c.session_file, p.name
|
|
67
|
+
FROM conversation c LEFT JOIN agent_preset p ON p.id = c.agent_id
|
|
68
|
+
WHERE c.id = ? AND c.group_id IS NOT NULL`)
|
|
69
|
+
.get(conversationId);
|
|
70
|
+
return row ?? null;
|
|
71
|
+
}
|
|
@@ -0,0 +1,61 @@
|
|
|
1
|
+
import { execFileSync } from "node:child_process";
|
|
2
|
+
import { existsSync, readFileSync, realpathSync } from "node:fs";
|
|
3
|
+
import { dirname, join } from "node:path";
|
|
4
|
+
import { fileURLToPath, pathToFileURL } from "node:url";
|
|
5
|
+
/**
|
|
6
|
+
* Les packages pi viennent de l'installation hôte (le `pi` du PATH), jamais d'une copie
|
|
7
|
+
* figée : une copie décalée fait diverger le catalogue providers, les logins et les
|
|
8
|
+
* payloads de raisonnement de ce que le binaire exécute réellement.
|
|
9
|
+
* Repli sur les copies locales uniquement en dev/tests (pas de `pi` sur le PATH).
|
|
10
|
+
*/
|
|
11
|
+
function manifestName(dir) {
|
|
12
|
+
const file = join(dir, "package.json");
|
|
13
|
+
return existsSync(file) ? JSON.parse(readFileSync(file, "utf8")).name : undefined;
|
|
14
|
+
}
|
|
15
|
+
function findPackageUp(name, from) {
|
|
16
|
+
for (let dir = from;; dir = dirname(dir)) {
|
|
17
|
+
if (manifestName(dir) === name)
|
|
18
|
+
return dir;
|
|
19
|
+
if (dirname(dir) === dir)
|
|
20
|
+
return null;
|
|
21
|
+
}
|
|
22
|
+
}
|
|
23
|
+
/** Dossier du package `name` selon la résolution node depuis `from`. */
|
|
24
|
+
function findPackage(name, from) {
|
|
25
|
+
for (let dir = from;; dir = dirname(dir)) {
|
|
26
|
+
const candidate = join(dir, "node_modules", name);
|
|
27
|
+
if (existsSync(join(candidate, "package.json")))
|
|
28
|
+
return candidate;
|
|
29
|
+
if (dirname(dir) === dir)
|
|
30
|
+
return null;
|
|
31
|
+
}
|
|
32
|
+
}
|
|
33
|
+
function hostBase() {
|
|
34
|
+
try {
|
|
35
|
+
const bins = execFileSync(process.platform === "win32" ? "where" : "which", process.platform === "win32" ? ["pi"] : ["-a", "pi"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim().split("\n").map((line) => line.trim());
|
|
36
|
+
// Un pi sous node_modules/.bin est le devDependency d'un projet, pas l'installation de l'utilisateur.
|
|
37
|
+
const bin = bins.find((path) => !/node_modules[\\/]\.bin[\\/]/.test(path)) ?? bins[0];
|
|
38
|
+
return bin ? findPackageUp("@earendil-works/pi-coding-agent", dirname(realpathSync(bin))) : null;
|
|
39
|
+
}
|
|
40
|
+
catch {
|
|
41
|
+
return null;
|
|
42
|
+
}
|
|
43
|
+
}
|
|
44
|
+
const bases = [hostBase(), findPackageUp("@ignitionai/cogitator", dirname(fileURLToPath(import.meta.url)))].filter((base) => base !== null);
|
|
45
|
+
function root(pkg) {
|
|
46
|
+
for (const base of bases) {
|
|
47
|
+
const found = findPackage(pkg, base);
|
|
48
|
+
if (found)
|
|
49
|
+
return found;
|
|
50
|
+
}
|
|
51
|
+
throw new Error(`package pi introuvable: ${pkg}`);
|
|
52
|
+
}
|
|
53
|
+
export const codingAgentRoot = root("@earendil-works/pi-coding-agent");
|
|
54
|
+
// Ces packages n'exposent qu'une condition "import" : chargement ESM dynamique.
|
|
55
|
+
const load = (...segments) => import(pathToFileURL(join(...segments)).href);
|
|
56
|
+
export const piAiRoot = root("@earendil-works/pi-ai");
|
|
57
|
+
export const piCodingAgent = await load(codingAgentRoot, "dist/index.js");
|
|
58
|
+
export const piAi = await load(piAiRoot, "dist/index.js");
|
|
59
|
+
export const piAiProviders = await load(piAiRoot, "dist/providers/all.js");
|
|
60
|
+
/** Entrée CLI exécutée en mode rpc (celle de l'hôte quand elle existe). */
|
|
61
|
+
export const piCliPath = join(codingAgentRoot, "dist/cli.js");
|