@ignitionai/cogitator 0.5.0 → 0.5.2
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/CHANGELOG.md +69 -0
- package/LICENSE +21 -0
- package/README.md +83 -44
- package/dist/extensions/index.js +66 -29
- package/dist/src/app-updates.js +15 -0
- package/dist/src/auth-cli.js +18 -8
- package/dist/src/auth-http.js +13 -3
- package/dist/src/auth-state.js +41 -6
- package/dist/src/board.js +3 -1
- package/dist/src/browser-http.js +143 -0
- package/dist/src/classic-configuration.js +12 -4
- package/dist/src/cli.js +30 -4
- package/dist/src/config.js +10 -0
- package/dist/src/cron.js +91 -15
- package/dist/src/db.js +55 -3
- package/dist/src/durable/approvals.js +17 -2
- package/dist/src/durable/effect-gateway.js +23 -16
- package/dist/src/durable/manager.js +15 -6
- package/dist/src/durable/mission-runtime.js +204 -46
- package/dist/src/durable/recovery.js +37 -0
- package/dist/src/durable/workers.js +22 -14
- package/dist/src/execution/confinement.js +2 -1
- package/dist/src/execution/worker-supervisor.js +222 -0
- package/dist/src/git-import.js +187 -0
- package/dist/src/github-login.js +101 -0
- package/dist/src/history.js +6 -1
- package/dist/src/host-pi.js +64 -0
- package/dist/src/json-files.js +7 -4
- package/dist/src/machine-metrics.js +49 -0
- package/dist/src/machine-types.js +1 -0
- package/dist/src/mcp-cli.js +63 -0
- package/dist/src/mcp-http.js +164 -0
- package/dist/src/mcp-oauth.js +502 -0
- package/dist/src/mcp-server.js +6 -136
- package/dist/src/mcp-tokens.js +104 -0
- package/dist/src/mcp-tools.js +264 -0
- package/dist/src/native-auth.js +9 -2
- package/dist/src/packages.js +190 -0
- package/dist/src/paths.js +1 -0
- package/dist/src/pi-child.js +180 -0
- package/dist/src/pi-rpc-wrap.js +84 -0
- package/dist/src/pool.js +58 -7
- package/dist/src/project-setup.js +63 -0
- package/dist/src/provider-login.js +73 -14
- package/dist/src/reap-orphans.js +138 -0
- package/dist/src/registry.js +68 -45
- package/dist/src/schemas.js +19 -4
- package/dist/src/server-compat.js +173 -0
- package/dist/src/server-identity.js +69 -0
- package/dist/src/server.js +534 -41
- package/dist/src/shared-browser.js +357 -0
- package/dist/src/skills-import.js +13 -4
- package/dist/src/skills-upload.js +68 -0
- package/dist/src/spawner.js +20 -4
- package/dist/src/subagents.js +242 -0
- package/dist/src/team-queue.js +262 -0
- package/package.json +13 -4
- package/web/dist/assets/BrandLogo3D-CHGXwTbZ.js +4035 -0
- package/web/dist/assets/index-DGLkhrE7.css +1 -0
- package/web/dist/assets/index-P0WoXBgX.js +84 -0
- package/web/dist/index.html +2 -2
- package/web/dist/assets/index-C3tRuOTh.js +0 -83
- package/web/dist/assets/index-DMQqB0r1.css +0 -1
|
@@ -0,0 +1,173 @@
|
|
|
1
|
+
import { readServerIdentity } from "./server-identity.js";
|
|
2
|
+
/** Message d'échec inchangé : l'utilisateur doit inspecter/arrêter lui-même l'instance en cause. */
|
|
3
|
+
export const UNAVAILABLE_MESSAGE = "Cogitator unavailable: check the server/auth state and stop incompatible previous instances.";
|
|
4
|
+
const PROBE_TIMEOUT_MS = 1_000;
|
|
5
|
+
const STARTUP_ATTEMPTS = 50;
|
|
6
|
+
const STARTUP_POLL_MS = 100;
|
|
7
|
+
/** Borne d'attente d'un SIGTERM accepté : au-delà on ne remonte pas en SIGKILL (jamais d'escalade). */
|
|
8
|
+
const STOP_TIMEOUT_MS = 10_000;
|
|
9
|
+
const STOP_POLL_MS = 200;
|
|
10
|
+
async function getJson(url, timeoutMs) {
|
|
11
|
+
try {
|
|
12
|
+
const res = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
|
|
13
|
+
let body;
|
|
14
|
+
try {
|
|
15
|
+
body = await res.json();
|
|
16
|
+
}
|
|
17
|
+
catch {
|
|
18
|
+
body = undefined; // réponse non JSON : traitée comme non identifiable
|
|
19
|
+
}
|
|
20
|
+
return { kind: "response", status: res.status, body };
|
|
21
|
+
}
|
|
22
|
+
catch {
|
|
23
|
+
return { kind: "down" };
|
|
24
|
+
}
|
|
25
|
+
}
|
|
26
|
+
/** Reconnaît le contrat `GET /api/health` (version + au moins un marqueur Cogitator). */
|
|
27
|
+
function recognizedHealth(body) {
|
|
28
|
+
if (!body || typeof body !== "object")
|
|
29
|
+
return undefined;
|
|
30
|
+
const r = body;
|
|
31
|
+
if (typeof r.version !== "string" || r.version === "")
|
|
32
|
+
return undefined;
|
|
33
|
+
if (r.ok !== true && !("pi_version" in r) && !("db" in r))
|
|
34
|
+
return undefined;
|
|
35
|
+
return r.version;
|
|
36
|
+
}
|
|
37
|
+
/** Reconnaît `GET /api/status` — la sonde historique de `isUp()`, seule accessible en mode auth. */
|
|
38
|
+
function recognizedStatus(body) {
|
|
39
|
+
return !!body && typeof body === "object" && body.service === "cogitator";
|
|
40
|
+
}
|
|
41
|
+
/**
|
|
42
|
+
* Sonde réelle : `/api/health` d'abord (version), puis `/api/status` en repli.
|
|
43
|
+
* Le repli préserve le comportement existant quand `/api/health` est filtré (auth
|
|
44
|
+
* requise, 5xx) : on se connecte sans comparer, et on ne tue jamais rien.
|
|
45
|
+
*/
|
|
46
|
+
export async function probeServer(baseUrl, timeoutMs = PROBE_TIMEOUT_MS) {
|
|
47
|
+
const health = await getJson(`${baseUrl}/api/health`, timeoutMs);
|
|
48
|
+
if (health.kind === "down")
|
|
49
|
+
return { kind: "down" };
|
|
50
|
+
const version = recognizedHealth(health.body);
|
|
51
|
+
if (version !== undefined)
|
|
52
|
+
return { kind: "cogitator", version };
|
|
53
|
+
const status = await getJson(`${baseUrl}/api/status`, timeoutMs);
|
|
54
|
+
if (status.kind === "response" && recognizedStatus(status.body))
|
|
55
|
+
return { kind: "cogitator", version: null };
|
|
56
|
+
return { kind: "foreign" };
|
|
57
|
+
}
|
|
58
|
+
/** Comparaison semver tolérante : numéros manquants = 0, pré-version < version finale. */
|
|
59
|
+
export function compareVersions(a, b) {
|
|
60
|
+
const parse = (value) => {
|
|
61
|
+
const [core = "", ...rest] = value.trim().replace(/^v/, "").split("+")[0].split("-");
|
|
62
|
+
const numbers = core.split(".").map((part) => (/^\d+$/.test(part) ? Number(part) : 0));
|
|
63
|
+
return { numbers, pre: rest.join("-") };
|
|
64
|
+
};
|
|
65
|
+
const left = parse(a);
|
|
66
|
+
const right = parse(b);
|
|
67
|
+
const length = Math.max(left.numbers.length, right.numbers.length);
|
|
68
|
+
for (let i = 0; i < length; i++) {
|
|
69
|
+
const diff = (left.numbers[i] ?? 0) - (right.numbers[i] ?? 0);
|
|
70
|
+
if (diff !== 0)
|
|
71
|
+
return diff > 0 ? 1 : -1;
|
|
72
|
+
}
|
|
73
|
+
if (left.pre && !right.pre)
|
|
74
|
+
return -1;
|
|
75
|
+
if (!left.pre && right.pre)
|
|
76
|
+
return 1;
|
|
77
|
+
if (left.pre === right.pre)
|
|
78
|
+
return 0;
|
|
79
|
+
return left.pre < right.pre ? -1 : 1;
|
|
80
|
+
}
|
|
81
|
+
function portOf(baseUrl) {
|
|
82
|
+
try {
|
|
83
|
+
const url = new URL(baseUrl);
|
|
84
|
+
if (url.port !== "")
|
|
85
|
+
return Number(url.port);
|
|
86
|
+
return url.protocol === "https:" ? 443 : url.protocol === "http:" ? 80 : null;
|
|
87
|
+
}
|
|
88
|
+
catch {
|
|
89
|
+
return null;
|
|
90
|
+
}
|
|
91
|
+
}
|
|
92
|
+
/**
|
|
93
|
+
* Garantit qu'un serveur compatible avec la version installée est disponible.
|
|
94
|
+
* Ordre : rien → démarrer ; version ≥ installée → se connecter ; version <
|
|
95
|
+
* installée → SIGTERM sur le pid du pidfile *si et seulement si* pidfile et
|
|
96
|
+
* réponse HTTP concordent, puis redémarrage. Toute ambiguïté → aucun kill.
|
|
97
|
+
*/
|
|
98
|
+
export async function ensureCompatibleServer(deps) {
|
|
99
|
+
const probe = await deps.probeServer(deps.baseUrl);
|
|
100
|
+
if (probe.kind === "down") {
|
|
101
|
+
const started = await startServer(deps, "started");
|
|
102
|
+
return started.action === "unavailable" ? started : { action: "started", version: started.version };
|
|
103
|
+
}
|
|
104
|
+
if (probe.kind === "foreign")
|
|
105
|
+
return { action: "unavailable", reason: "foreign-service" };
|
|
106
|
+
if (probe.version === null)
|
|
107
|
+
return { action: "connected", version: null };
|
|
108
|
+
if (compareVersions(probe.version, deps.installedVersion) >= 0) {
|
|
109
|
+
return { action: "connected", version: probe.version };
|
|
110
|
+
}
|
|
111
|
+
const identity = deps.readIdentity();
|
|
112
|
+
const port = portOf(deps.baseUrl);
|
|
113
|
+
const coherent = identity !== null &&
|
|
114
|
+
identity.pid !== process.pid &&
|
|
115
|
+
identity.version === probe.version &&
|
|
116
|
+
port !== null &&
|
|
117
|
+
identity.port === port &&
|
|
118
|
+
deps.isAlive(identity.pid);
|
|
119
|
+
if (!identity || !coherent)
|
|
120
|
+
return { action: "unavailable", reason: "incoherent-pidfile" };
|
|
121
|
+
try {
|
|
122
|
+
deps.kill(identity.pid, "SIGTERM");
|
|
123
|
+
}
|
|
124
|
+
catch {
|
|
125
|
+
return { action: "unavailable", reason: "incoherent-pidfile" };
|
|
126
|
+
}
|
|
127
|
+
if (!(await waitForStop(deps, identity.pid)))
|
|
128
|
+
return { action: "unavailable", reason: "stop-timeout" };
|
|
129
|
+
const started = await startServer(deps, "restarted");
|
|
130
|
+
if (started.action === "unavailable")
|
|
131
|
+
return started;
|
|
132
|
+
return { action: "restarted", version: started.version, stoppedPid: identity.pid };
|
|
133
|
+
}
|
|
134
|
+
async function startServer(deps, action) {
|
|
135
|
+
deps.spawnServer();
|
|
136
|
+
const attempts = deps.startupAttempts ?? STARTUP_ATTEMPTS;
|
|
137
|
+
const pollMs = deps.startupPollMs ?? STARTUP_POLL_MS;
|
|
138
|
+
for (let i = 0; i < attempts; i++) {
|
|
139
|
+
await deps.sleep(pollMs);
|
|
140
|
+
const probe = await deps.probeServer(deps.baseUrl);
|
|
141
|
+
if (probe.kind === "cogitator")
|
|
142
|
+
return { action, version: probe.version };
|
|
143
|
+
}
|
|
144
|
+
return { action: "unavailable", reason: "start-timeout" };
|
|
145
|
+
}
|
|
146
|
+
async function waitForStop(deps, pid) {
|
|
147
|
+
const now = deps.now ?? Date.now;
|
|
148
|
+
const deadline = now() + (deps.stopTimeoutMs ?? STOP_TIMEOUT_MS);
|
|
149
|
+
const pollMs = deps.stopPollMs ?? STOP_POLL_MS;
|
|
150
|
+
for (;;) {
|
|
151
|
+
const alive = deps.isAlive(pid);
|
|
152
|
+
const probe = await deps.probeServer(deps.baseUrl);
|
|
153
|
+
if (!alive && probe.kind === "down")
|
|
154
|
+
return true;
|
|
155
|
+
if (now() >= deadline)
|
|
156
|
+
return false;
|
|
157
|
+
await deps.sleep(pollMs);
|
|
158
|
+
}
|
|
159
|
+
}
|
|
160
|
+
/**
|
|
161
|
+
* Garde de démarrage (CLI) : refuse d'écraser un pidfile dont le PID est vivant
|
|
162
|
+
* et répond comme Cogitator sur le port qu'il déclare. Un pidfile périmé (PID
|
|
163
|
+
* mort, ou vivant mais muet) est remplacé sans bruit : c'est un arrêt brutal.
|
|
164
|
+
*/
|
|
165
|
+
export async function assertNoLiveInstance(home, opts) {
|
|
166
|
+
const identity = readServerIdentity(home);
|
|
167
|
+
if (!identity || !opts.isAlive(identity.pid))
|
|
168
|
+
return;
|
|
169
|
+
const probe = await opts.probeServer(`http://${opts.host ?? "127.0.0.1"}:${identity.port}`);
|
|
170
|
+
if (probe.kind !== "cogitator")
|
|
171
|
+
return;
|
|
172
|
+
throw new Error(`Cogitator ${identity.version} is already running (pid ${identity.pid}, port ${identity.port}). Stop it before starting another server.`);
|
|
173
|
+
}
|
|
@@ -0,0 +1,69 @@
|
|
|
1
|
+
import { chmodSync, closeSync, fsyncSync, openSync, readFileSync, renameSync, unlinkSync, writeSync } from "node:fs";
|
|
2
|
+
import { join } from "node:path";
|
|
3
|
+
/** `<home>/server.pid` — même home que la base et le verrou d'instance. */
|
|
4
|
+
export function serverIdentityPath(home) {
|
|
5
|
+
return join(home, "server.pid");
|
|
6
|
+
}
|
|
7
|
+
/** Valide strictement le contenu d'un pidfile ; `null` si absent, illisible ou incohérent. */
|
|
8
|
+
export function parseServerIdentity(raw) {
|
|
9
|
+
if (!raw || typeof raw !== "object")
|
|
10
|
+
return null;
|
|
11
|
+
const r = raw;
|
|
12
|
+
const { pid, version, port, startedAt } = r;
|
|
13
|
+
if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0)
|
|
14
|
+
return null;
|
|
15
|
+
if (typeof version !== "string" || version.trim() === "")
|
|
16
|
+
return null;
|
|
17
|
+
if (typeof port !== "number" || !Number.isInteger(port) || port <= 0 || port > 65_535)
|
|
18
|
+
return null;
|
|
19
|
+
if (typeof startedAt !== "string" || startedAt === "")
|
|
20
|
+
return null;
|
|
21
|
+
return { pid, version, port, startedAt };
|
|
22
|
+
}
|
|
23
|
+
export function readServerIdentity(home) {
|
|
24
|
+
try {
|
|
25
|
+
return parseServerIdentity(JSON.parse(readFileSync(serverIdentityPath(home), "utf8")));
|
|
26
|
+
}
|
|
27
|
+
catch {
|
|
28
|
+
return null;
|
|
29
|
+
}
|
|
30
|
+
}
|
|
31
|
+
/** Écriture atomique (tmp + rename), mode 0600 : un lecteur ne voit jamais un JSON partiel. */
|
|
32
|
+
export function writeServerIdentity(home, identity) {
|
|
33
|
+
const target = serverIdentityPath(home);
|
|
34
|
+
const tmp = `${target}.${process.pid}.tmp`;
|
|
35
|
+
const fd = openSync(tmp, "w", 0o600);
|
|
36
|
+
try {
|
|
37
|
+
writeSync(fd, JSON.stringify(identity));
|
|
38
|
+
fsyncSync(fd);
|
|
39
|
+
}
|
|
40
|
+
finally {
|
|
41
|
+
closeSync(fd);
|
|
42
|
+
}
|
|
43
|
+
chmodSync(tmp, 0o600);
|
|
44
|
+
renameSync(tmp, target);
|
|
45
|
+
}
|
|
46
|
+
/** Supprime le pidfile seulement s'il désigne encore `pid` (jamais celui d'une instance plus récente). */
|
|
47
|
+
export function removeServerIdentity(home, pid) {
|
|
48
|
+
const current = readServerIdentity(home);
|
|
49
|
+
if (current && current.pid !== pid)
|
|
50
|
+
return;
|
|
51
|
+
try {
|
|
52
|
+
unlinkSync(serverIdentityPath(home));
|
|
53
|
+
}
|
|
54
|
+
catch {
|
|
55
|
+
// Déjà supprimé (arrêt concurrent) : rien à faire.
|
|
56
|
+
}
|
|
57
|
+
}
|
|
58
|
+
/** `kill(pid, 0)` : vrai si le process existe encore, y compris sans droit de signal. */
|
|
59
|
+
export function isProcessAlive(pid) {
|
|
60
|
+
if (!Number.isInteger(pid) || pid <= 0)
|
|
61
|
+
return false;
|
|
62
|
+
try {
|
|
63
|
+
process.kill(pid, 0);
|
|
64
|
+
return true;
|
|
65
|
+
}
|
|
66
|
+
catch (err) {
|
|
67
|
+
return err.code === "EPERM";
|
|
68
|
+
}
|
|
69
|
+
}
|