@ignitionai/cogitator 0.7.0 → 0.8.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/CHANGELOG.md +8 -0
- package/README.md +1 -1
- package/dist/src/self-update.js +70 -4
- package/dist/src/server.js +3 -1
- package/dist/src/updater/cogitator-updater.js +467 -0
- package/package.json +3 -2
- package/web/dist/assets/{BrandLogo3D-C9FpJ_0_.js → BrandLogo3D-cPJ_Ew_L.js} +1 -1
- package/web/dist/assets/index-9EdUaibN.js +85 -0
- package/web/dist/index.html +1 -1
- package/web/dist/assets/index-oq5ljXBg.js +0 -85
package/CHANGELOG.md
CHANGED
|
@@ -2,6 +2,14 @@
|
|
|
2
2
|
|
|
3
3
|
User-facing changes to Cogitator. GitHub development updates and npm releases are separate: an entry marked **Unreleased** is not yet available from npm.
|
|
4
4
|
|
|
5
|
+
## [0.8.0] - 2026-11-22
|
|
6
|
+
|
|
7
|
+
**Highlight:** the same one-click update on a systemd VPS, with automatic rollback.
|
|
8
|
+
|
|
9
|
+
### Added
|
|
10
|
+
|
|
11
|
+
- **One-click updates on a VPS (cogitator-updater):** a small root service for systemd installations. Cogitator only drops a request (a version number). The service accepts only the latest published release, downloads it, installs it as a new release and verifies npm signatures and provenance. It then switches `/opt/cogitator/current`, restarts Cogitator and checks that the new version is served. If the new version does not start, it automatically returns to the previous one. The code stays protected from the service account. Install it once with `sudo node /opt/cogitator/current/dist/src/updater/cogitator-updater.js install --user cogitator`. See [VPS updates](https://github.com/IgnitionAI/cogitator/blob/dev/docs/updater.md).
|
|
12
|
+
|
|
5
13
|
## [0.7.0] - 2026-11-22
|
|
6
14
|
|
|
7
15
|
**Highlight:** update Cogitator and your pi extensions in one click.
|
package/README.md
CHANGED
|
@@ -14,7 +14,7 @@
|
|
|
14
14
|
|
|
15
15
|
Cogitator is a **pi package and web UI**, not a separate hosted AI service. Connect your model providers, open a bot, and work through conversations, projects, skills and subagents. Your installation keeps its own data and credentials. The interface is available in **English and French**, including on mobile.
|
|
16
16
|
|
|
17
|
-
> **Release status:** this README describes the current `dev` build. **0.
|
|
17
|
+
> **Release status:** this README describes the current `dev` build. **0.8.0** is published on npm, and the badge above shows the latest published version. Any later entry marked **Unreleased** in the [changelog](https://github.com/IgnitionAI/cogitator/blob/dev/CHANGELOG.md) requires a source build until it is published.
|
|
18
18
|
|
|
19
19
|

|
|
20
20
|
|
package/dist/src/self-update.js
CHANGED
|
@@ -10,11 +10,45 @@
|
|
|
10
10
|
* compte du serveur (protection voulue) ; l'UI affiche alors la procédure du guide VPS.
|
|
11
11
|
*/
|
|
12
12
|
import { spawn } from "node:child_process";
|
|
13
|
-
import { existsSync, readFileSync, realpathSync } from "node:fs";
|
|
13
|
+
import { accessSync, constants, existsSync, readFileSync, realpathSync, renameSync, writeFileSync } from "node:fs";
|
|
14
14
|
import { join, sep } from "node:path";
|
|
15
15
|
import { findPackageRoot } from "./default-agent.js";
|
|
16
16
|
export const PACKAGE = "@ignitionai/cogitator";
|
|
17
|
+
/** Dossier d'état du service cogitator-updater (voir src/updater/cogitator-updater.ts). */
|
|
18
|
+
export function updaterDir(env = process.env) {
|
|
19
|
+
return env.COGITATOR_UPDATER_DIR ?? "/var/lib/cogitator-updater";
|
|
20
|
+
}
|
|
21
|
+
/** Updater installé : status.json lisible et inbox/ accessible en écriture pour ce compte. */
|
|
22
|
+
export function updaterAvailable(dir) {
|
|
23
|
+
try {
|
|
24
|
+
accessSync(join(dir, "status.json"), constants.R_OK);
|
|
25
|
+
accessSync(join(dir, "inbox"), constants.W_OK | constants.X_OK);
|
|
26
|
+
return true;
|
|
27
|
+
}
|
|
28
|
+
catch {
|
|
29
|
+
return false;
|
|
30
|
+
}
|
|
31
|
+
}
|
|
32
|
+
export function readUpdaterStatus(dir) {
|
|
33
|
+
try {
|
|
34
|
+
return JSON.parse(readFileSync(join(dir, "status.json"), "utf8"));
|
|
35
|
+
}
|
|
36
|
+
catch {
|
|
37
|
+
return null;
|
|
38
|
+
}
|
|
39
|
+
}
|
|
40
|
+
/** Dépôt atomique de la demande (fichier temporaire du même dossier puis rename). */
|
|
41
|
+
export function requestUpdater(dir, version) {
|
|
42
|
+
const inbox = join(dir, "inbox");
|
|
43
|
+
const tmp = join(inbox, `.request-${process.pid}-${Date.now()}.json`);
|
|
44
|
+
writeFileSync(tmp, JSON.stringify({ version, requested_at: new Date().toISOString() }), { mode: 0o640 });
|
|
45
|
+
renameSync(tmp, join(inbox, "request.json"));
|
|
46
|
+
}
|
|
17
47
|
export function selfUpdateSupport(paths, root = findPackageRoot(), env = process.env) {
|
|
48
|
+
if (env.COGITATOR_SELF_UPDATE === "0")
|
|
49
|
+
return { supported: false, reason: "SERVICE_MANAGED" };
|
|
50
|
+
if (updaterAvailable(updaterDir(env)))
|
|
51
|
+
return { supported: true, mode: "updater" };
|
|
18
52
|
if (!root)
|
|
19
53
|
return { supported: false, reason: "SOURCE_BUILD" };
|
|
20
54
|
const piModules = join(paths.piAgentDir, "npm", "node_modules");
|
|
@@ -29,9 +63,9 @@ export function selfUpdateSupport(paths, root = findPackageRoot(), env = process
|
|
|
29
63
|
if (!real.startsWith(base + sep))
|
|
30
64
|
return { supported: false, reason: "NOT_PI_MANAGED" };
|
|
31
65
|
// Un service (systemd) gère lui-même le cycle de vie : pas de relance concurrente.
|
|
32
|
-
if (env.INVOCATION_ID
|
|
66
|
+
if (env.INVOCATION_ID)
|
|
33
67
|
return { supported: false, reason: "SERVICE_MANAGED" };
|
|
34
|
-
return { supported: true };
|
|
68
|
+
return { supported: true, mode: "pi" };
|
|
35
69
|
}
|
|
36
70
|
export class SelfUpdateError extends Error {
|
|
37
71
|
code;
|
|
@@ -46,10 +80,33 @@ export class SelfUpdateError extends Error {
|
|
|
46
80
|
}
|
|
47
81
|
export class SelfUpdater {
|
|
48
82
|
deps;
|
|
49
|
-
|
|
83
|
+
internal = { status: "idle" };
|
|
84
|
+
requestedAt = 0;
|
|
50
85
|
constructor(deps) {
|
|
51
86
|
this.deps = deps;
|
|
52
87
|
}
|
|
88
|
+
/** État courant ; en mode updater, il suit le status.json du service root. */
|
|
89
|
+
get state() {
|
|
90
|
+
const s = this.internal;
|
|
91
|
+
// Processus relancé après un retour arrière : signaler l'échec récent du service updater.
|
|
92
|
+
if (s.status === "idle" && this.deps.updaterStatus) {
|
|
93
|
+
const u = this.deps.updaterStatus();
|
|
94
|
+
if (u && (u.status === "rolled-back" || u.status === "error") && u.at && Date.now() - Date.parse(u.at) < 5 * 60_000) {
|
|
95
|
+
return { status: "error", target: u.target, step: u.status, error: u.message ?? u.status };
|
|
96
|
+
}
|
|
97
|
+
}
|
|
98
|
+
if (!this.requestedAt || s.status !== "installing" || !this.deps.updaterStatus)
|
|
99
|
+
return s;
|
|
100
|
+
const u = this.deps.updaterStatus();
|
|
101
|
+
if (!u || u.target !== s.target || (u.at && Date.parse(u.at) < this.requestedAt - 1000))
|
|
102
|
+
return s;
|
|
103
|
+
if (u.status === "error" || u.status === "rolled-back")
|
|
104
|
+
return { status: "error", target: s.target, step: u.status, error: u.message ?? u.status };
|
|
105
|
+
if (u.status === "restarting" || u.status === "verifying" || u.status === "rolling-back")
|
|
106
|
+
return { status: "restarting", target: s.target, step: u.status };
|
|
107
|
+
return { ...s, step: u.status };
|
|
108
|
+
}
|
|
109
|
+
set state(value) { this.internal = value; }
|
|
53
110
|
/** Lance la mise à jour ; l'installation se poursuit en tâche de fond (suivie par `state`). */
|
|
54
111
|
async start(force = false) {
|
|
55
112
|
if (this.state.status === "installing" || this.state.status === "restarting")
|
|
@@ -64,6 +121,15 @@ export class SelfUpdater {
|
|
|
64
121
|
if (busy > 0 && !force)
|
|
65
122
|
throw new SelfUpdateError("SELF_UPDATE_BUSY", 409, { busy });
|
|
66
123
|
const target = release.latest;
|
|
124
|
+
if (support.mode === "updater") {
|
|
125
|
+
if (!this.deps.requestUpdater)
|
|
126
|
+
throw new SelfUpdateError("SELF_UPDATE_SERVICE_MANAGED", 400);
|
|
127
|
+
this.deps.requestUpdater(target);
|
|
128
|
+
this.requestedAt = Date.now();
|
|
129
|
+
this.state = { status: "installing", target, step: "requested" };
|
|
130
|
+
return { ...this.state };
|
|
131
|
+
}
|
|
132
|
+
this.requestedAt = 0;
|
|
67
133
|
this.state = { status: "installing", target };
|
|
68
134
|
void this.run(target);
|
|
69
135
|
return { ...this.state };
|
package/dist/src/server.js
CHANGED
|
@@ -46,7 +46,7 @@ import { cloneRepo, isInsideDir, localDirFor } from "./git-import.js";
|
|
|
46
46
|
import { listSubagents, readSubagentTranscript } from "./subagents.js";
|
|
47
47
|
import { MCP_HTTP_PATH, McpHttpEndpoint } from "./mcp-http.js";
|
|
48
48
|
import { McpOAuth } from "./mcp-oauth.js";
|
|
49
|
-
import { installedPackageVersion, PACKAGE as SELF_PACKAGE, SelfUpdateError, SelfUpdater, selfUpdateSupport, spawnRelauncher } from "./self-update.js";
|
|
49
|
+
import { installedPackageVersion, readUpdaterStatus, requestUpdater, updaterDir, PACKAGE as SELF_PACKAGE, SelfUpdateError, SelfUpdater, selfUpdateSupport, spawnRelauncher } from "./self-update.js";
|
|
50
50
|
import { loadPty, shellLaunch, terminalEnv, TerminalError, TerminalManager } from "./terminal.js";
|
|
51
51
|
import { attachTerminalSocket, terminalRoutes } from "./terminal-http.js";
|
|
52
52
|
import { piComplete } from "./terminal-assist.js";
|
|
@@ -280,6 +280,8 @@ function registryRoutes(deps) {
|
|
|
280
280
|
install: (source) => runPi("install", source, paths),
|
|
281
281
|
installedVersion: () => installedPackageVersion(),
|
|
282
282
|
relaunch: () => spawnRelauncher(),
|
|
283
|
+
requestUpdater: (version) => requestUpdater(updaterDir(), version),
|
|
284
|
+
updaterStatus: () => readUpdaterStatus(updaterDir()),
|
|
283
285
|
shutdown: () => {
|
|
284
286
|
// Arrêt habituel (cli.ts) ; filet de sécurité si une poignée retient le processus.
|
|
285
287
|
setTimeout(() => process.exit(0), 15_000).unref();
|
|
@@ -0,0 +1,467 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
/**
|
|
3
|
+
* cogitator-updater — service root de mise à jour pour une installation systemd
|
|
4
|
+
* (releases sous /opt/cogitator/releases, lien /opt/cogitator/current).
|
|
5
|
+
*
|
|
6
|
+
* Autonome (modules Node + CLI npm uniquement) : `install` le copie hors du code de
|
|
7
|
+
* Cogitator, appartenant à root. Le compte du serveur ne peut que DÉPOSER une demande
|
|
8
|
+
* (inbox/request.json, contenu : une version). Le service vérifie qu'il s'agit de la
|
|
9
|
+
* dernière version publiée sur npm, puis : npm pack (intégrité du registre) → release
|
|
10
|
+
* neuve → npm install --omit=dev → npm audit signatures → bascule atomique de `current`
|
|
11
|
+
* → systemctl restart → vérification (version servie + /api/status). Échec après la
|
|
12
|
+
* bascule : retour automatique à la release précédente.
|
|
13
|
+
*
|
|
14
|
+
* Commandes : install | run | status | uninstall (voir docs/updater.md)
|
|
15
|
+
*/
|
|
16
|
+
import { spawnSync } from "node:child_process";
|
|
17
|
+
import { randomBytes } from "node:crypto";
|
|
18
|
+
import { chmodSync, chownSync, closeSync, copyFileSync, existsSync, fstatSync, mkdirSync, openSync, readFileSync, readdirSync, readlinkSync, renameSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync, constants, } from "node:fs";
|
|
19
|
+
import { basename, dirname, join } from "node:path";
|
|
20
|
+
import { fileURLToPath } from "node:url";
|
|
21
|
+
export const PACKAGE = "@ignitionai/cogitator";
|
|
22
|
+
export const DEFAULT_CONFIG = "/etc/cogitator-updater.json";
|
|
23
|
+
const INSTALL_DIR = "/usr/local/lib/cogitator-updater";
|
|
24
|
+
const SYSTEMD_DIR = "/etc/systemd/system";
|
|
25
|
+
const RELEASE_PREFIX = "npm-";
|
|
26
|
+
const KEEP_RELEASES = 3;
|
|
27
|
+
const LOCK_STALE_MS = 30 * 60_000;
|
|
28
|
+
export function defaults(partial = {}) {
|
|
29
|
+
return {
|
|
30
|
+
unit: "cogitator.service", user: "cogitator", releases: "/opt/cogitator/releases", current: "/opt/cogitator/current",
|
|
31
|
+
stateDir: "/var/lib/cogitator-updater", home: "/var/lib/cogitator", port: 5320, registry: "https://registry.npmjs.org",
|
|
32
|
+
npm: "npm", systemctl: "systemctl", tar: "tar", verifyTimeoutMs: 90_000, ...partial,
|
|
33
|
+
};
|
|
34
|
+
}
|
|
35
|
+
export function loadConfig(path = DEFAULT_CONFIG) {
|
|
36
|
+
return defaults(JSON.parse(readFileSync(path, "utf8")));
|
|
37
|
+
}
|
|
38
|
+
const STABLE = /^\d+\.\d+\.\d+$/;
|
|
39
|
+
export function newer(a, b) {
|
|
40
|
+
if (!STABLE.test(a) || !STABLE.test(b))
|
|
41
|
+
return false;
|
|
42
|
+
const x = a.split(".").map(Number), y = b.split(".").map(Number);
|
|
43
|
+
for (let i = 0; i < 3; i++)
|
|
44
|
+
if (x[i] !== y[i])
|
|
45
|
+
return x[i] > y[i];
|
|
46
|
+
return false;
|
|
47
|
+
}
|
|
48
|
+
function now() { return new Date().toISOString(); }
|
|
49
|
+
export function writeStatus(cfg, status) {
|
|
50
|
+
const file = join(cfg.stateDir, "status.json");
|
|
51
|
+
const tmp = `${file}.${process.pid}.tmp`;
|
|
52
|
+
writeFileSync(tmp, JSON.stringify({ ...status, at: now() }, null, 2) + "\n", { mode: 0o644 });
|
|
53
|
+
renameSync(tmp, file);
|
|
54
|
+
}
|
|
55
|
+
export function readStatus(cfg) {
|
|
56
|
+
try {
|
|
57
|
+
return JSON.parse(readFileSync(join(cfg.stateDir, "status.json"), "utf8"));
|
|
58
|
+
}
|
|
59
|
+
catch {
|
|
60
|
+
return null;
|
|
61
|
+
}
|
|
62
|
+
}
|
|
63
|
+
function run(cmd, args, opts = {}) {
|
|
64
|
+
const r = spawnSync(cmd, args, { cwd: opts.cwd, env: opts.env ?? process.env, encoding: "utf8", timeout: opts.timeoutMs ?? 600_000, maxBuffer: 32 * 1024 * 1024 });
|
|
65
|
+
if (r.error)
|
|
66
|
+
throw new Error(`${basename(cmd)} : ${r.error.message}`);
|
|
67
|
+
if (r.status !== 0)
|
|
68
|
+
throw new Error(`${basename(cmd)} ${args[0] ?? ""} a échoué (code ${r.status}) : ${(r.stderr || r.stdout || "").trim().split("\n").slice(-3).join(" ")}`);
|
|
69
|
+
return r.stdout;
|
|
70
|
+
}
|
|
71
|
+
function uidOf(user) {
|
|
72
|
+
const r = spawnSync("id", ["-u", user], { encoding: "utf8" });
|
|
73
|
+
return r.status === 0 ? Number(r.stdout.trim()) : null;
|
|
74
|
+
}
|
|
75
|
+
/**
|
|
76
|
+
* Lit puis supprime la demande. Refuse lien symbolique, fichier non régulier, trop gros,
|
|
77
|
+
* ou dont le propriétaire n'est ni root ni le compte du service.
|
|
78
|
+
*/
|
|
79
|
+
export function takeRequest(cfg, allowedUids) {
|
|
80
|
+
const file = join(cfg.stateDir, "inbox", "request.json");
|
|
81
|
+
if (!existsSync(file))
|
|
82
|
+
return null;
|
|
83
|
+
let fd;
|
|
84
|
+
try {
|
|
85
|
+
fd = openSync(file, constants.O_RDONLY | constants.O_NOFOLLOW);
|
|
86
|
+
}
|
|
87
|
+
catch {
|
|
88
|
+
unlinkSync(file);
|
|
89
|
+
throw new Error("Demande refusée : lien ou fichier illisible.");
|
|
90
|
+
}
|
|
91
|
+
try {
|
|
92
|
+
const st = fstatSync(fd);
|
|
93
|
+
if (!st.isFile() || st.size > 1024)
|
|
94
|
+
throw new Error("Demande refusée : fichier invalide.");
|
|
95
|
+
if (!allowedUids.includes(st.uid))
|
|
96
|
+
throw new Error("Demande refusée : propriétaire inattendu.");
|
|
97
|
+
const data = JSON.parse(readFileSync(fd, "utf8"));
|
|
98
|
+
if (typeof data.version !== "string" || !STABLE.test(data.version))
|
|
99
|
+
throw new Error("Demande refusée : version invalide.");
|
|
100
|
+
return { version: data.version };
|
|
101
|
+
}
|
|
102
|
+
finally {
|
|
103
|
+
closeSync(fd);
|
|
104
|
+
try {
|
|
105
|
+
unlinkSync(file);
|
|
106
|
+
}
|
|
107
|
+
catch { /* déjà retirée */ }
|
|
108
|
+
}
|
|
109
|
+
}
|
|
110
|
+
export async function latestVersion(cfg) {
|
|
111
|
+
const res = await fetch(`${cfg.registry}/${PACKAGE.replace("/", "%2F")}/latest`, { signal: AbortSignal.timeout(20_000), redirect: "error" });
|
|
112
|
+
if (!res.ok)
|
|
113
|
+
throw new Error(`Registre npm indisponible (HTTP ${res.status}).`);
|
|
114
|
+
const data = await res.json();
|
|
115
|
+
if (data.name !== PACKAGE || typeof data.version !== "string" || !STABLE.test(data.version))
|
|
116
|
+
throw new Error("Métadonnées npm invalides.");
|
|
117
|
+
return data.version;
|
|
118
|
+
}
|
|
119
|
+
export function releaseVersion(dir) {
|
|
120
|
+
try {
|
|
121
|
+
const v = JSON.parse(readFileSync(join(dir, "package.json"), "utf8")).version;
|
|
122
|
+
return typeof v === "string" ? v : null;
|
|
123
|
+
}
|
|
124
|
+
catch {
|
|
125
|
+
return null;
|
|
126
|
+
}
|
|
127
|
+
}
|
|
128
|
+
function servedVersion(cfg) {
|
|
129
|
+
try {
|
|
130
|
+
const v = JSON.parse(readFileSync(join(cfg.home, "server.pid"), "utf8")).version;
|
|
131
|
+
return typeof v === "string" ? v : null;
|
|
132
|
+
}
|
|
133
|
+
catch {
|
|
134
|
+
return null;
|
|
135
|
+
}
|
|
136
|
+
}
|
|
137
|
+
async function statusOk(cfg) {
|
|
138
|
+
try {
|
|
139
|
+
return (await fetch(`http://127.0.0.1:${cfg.port}/api/status`, { signal: AbortSignal.timeout(3000) })).ok;
|
|
140
|
+
}
|
|
141
|
+
catch {
|
|
142
|
+
return false;
|
|
143
|
+
}
|
|
144
|
+
}
|
|
145
|
+
/** La version attendue est servie ET le serveur répond. */
|
|
146
|
+
export async function waitServing(cfg, version) {
|
|
147
|
+
const deadline = Date.now() + cfg.verifyTimeoutMs;
|
|
148
|
+
while (Date.now() < deadline) {
|
|
149
|
+
if (servedVersion(cfg) === version && await statusOk(cfg))
|
|
150
|
+
return true;
|
|
151
|
+
await new Promise((r) => setTimeout(r, 1000));
|
|
152
|
+
}
|
|
153
|
+
return false;
|
|
154
|
+
}
|
|
155
|
+
/** Bascule atomique du lien `current` (lien temporaire + rename). */
|
|
156
|
+
export function pointCurrent(cfg, target) {
|
|
157
|
+
const tmp = `${cfg.current}.tmp-${randomBytes(4).toString("hex")}`;
|
|
158
|
+
symlinkSync(target, tmp);
|
|
159
|
+
renameSync(tmp, cfg.current);
|
|
160
|
+
}
|
|
161
|
+
function npmEnv(cache) {
|
|
162
|
+
return { ...process.env, npm_config_cache: cache, npm_config_update_notifier: "false", npm_config_fund: "false", npm_config_audit: "false" };
|
|
163
|
+
}
|
|
164
|
+
function manifest(dir) {
|
|
165
|
+
try {
|
|
166
|
+
return JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
|
|
167
|
+
}
|
|
168
|
+
catch {
|
|
169
|
+
return {};
|
|
170
|
+
}
|
|
171
|
+
}
|
|
172
|
+
/**
|
|
173
|
+
* Les peerDependencies (pi) ne sont pas installées par `npm install` dans le paquet lui-même :
|
|
174
|
+
* on les ajoute explicitement, à la version figée des devDependencies quand le peer accepte tout.
|
|
175
|
+
*/
|
|
176
|
+
export function peerSpecs(dir) {
|
|
177
|
+
const m = manifest(dir);
|
|
178
|
+
return Object.fromEntries(Object.entries(m.peerDependencies ?? {}).map(([name, range]) => [name, range === "*" && m.devDependencies?.[name] ? m.devDependencies[name] : range]));
|
|
179
|
+
}
|
|
180
|
+
/**
|
|
181
|
+
* Manifeste de la release : peers ajoutés aux dépendances (sinon non installés), devDependencies
|
|
182
|
+
* retirées (sinon un peer aussi listé en dev serait omis par --omit=dev).
|
|
183
|
+
*/
|
|
184
|
+
export function prepareManifest(dir) {
|
|
185
|
+
const m = manifest(dir);
|
|
186
|
+
const next = { ...m, dependencies: { ...(m.dependencies ?? {}), ...peerSpecs(dir) } };
|
|
187
|
+
delete next.devDependencies;
|
|
188
|
+
writeFileSync(join(dir, "package.json"), JSON.stringify(next, null, 2) + "\n");
|
|
189
|
+
}
|
|
190
|
+
function complete(dir, version) {
|
|
191
|
+
if (releaseVersion(dir) !== version || !existsSync(join(dir, "dist", "src", "cli.js")))
|
|
192
|
+
return false;
|
|
193
|
+
return Object.keys(manifest(dir).peerDependencies ?? {}).every((name) => existsSync(join(dir, "node_modules", name, "package.json")));
|
|
194
|
+
}
|
|
195
|
+
/** Construit la release `npm-<version>` (réutilisée si déjà complète). */
|
|
196
|
+
export function buildRelease(cfg, version, onPhase) {
|
|
197
|
+
const final = join(cfg.releases, `${RELEASE_PREFIX}${version}`);
|
|
198
|
+
if (complete(final, version))
|
|
199
|
+
return final;
|
|
200
|
+
mkdirSync(cfg.releases, { recursive: true });
|
|
201
|
+
const work = join(cfg.releases, `.work-${version}-${randomBytes(4).toString("hex")}`);
|
|
202
|
+
mkdirSync(work, { mode: 0o755 });
|
|
203
|
+
try {
|
|
204
|
+
const cache = join(work, ".npm-cache");
|
|
205
|
+
const pack = join(work, ".pack");
|
|
206
|
+
const root = join(work, "release");
|
|
207
|
+
mkdirSync(pack);
|
|
208
|
+
mkdirSync(root);
|
|
209
|
+
onPhase("downloading");
|
|
210
|
+
// npm pack vérifie l'intégrité (sha512) annoncée par le registre.
|
|
211
|
+
const out = run(cfg.npm, ["pack", `${PACKAGE}@${version}`, "--pack-destination", pack, "--json"], { cwd: work, env: npmEnv(cache) });
|
|
212
|
+
const file = JSON.parse(out)[0];
|
|
213
|
+
if (!file || file.version !== version)
|
|
214
|
+
throw new Error("Paquet npm inattendu.");
|
|
215
|
+
run(cfg.tar, ["-xzf", join(pack, basename(file.filename)), "-C", root, "--strip-components=1", "--no-same-owner"]);
|
|
216
|
+
if (releaseVersion(root) !== version)
|
|
217
|
+
throw new Error("Version du paquet extrait inattendue.");
|
|
218
|
+
onPhase("installing");
|
|
219
|
+
prepareManifest(root);
|
|
220
|
+
run(cfg.npm, ["install", "--omit=dev", "--no-audit", "--no-fund", "--no-package-lock"], { cwd: root, env: npmEnv(cache) });
|
|
221
|
+
// Signatures du registre et attestations de provenance des paquets installés.
|
|
222
|
+
run(cfg.npm, ["audit", "signatures"], { cwd: root, env: npmEnv(cache) });
|
|
223
|
+
if (!complete(root, version))
|
|
224
|
+
throw new Error("Release incomplète : dist/src/cli.js ou une dépendance pi manquante.");
|
|
225
|
+
run("chmod", ["-R", "go-w", root]);
|
|
226
|
+
rmSync(final, { recursive: true, force: true });
|
|
227
|
+
renameSync(root, final);
|
|
228
|
+
return final;
|
|
229
|
+
}
|
|
230
|
+
finally {
|
|
231
|
+
rmSync(work, { recursive: true, force: true });
|
|
232
|
+
}
|
|
233
|
+
}
|
|
234
|
+
/** Garde la release active, la précédente et les plus récentes `npm-*` (3 au total) ; ne touche jamais aux autres. */
|
|
235
|
+
export function pruneReleases(cfg, keep) {
|
|
236
|
+
const releases = readdirSync(cfg.releases).filter((n) => n.startsWith(RELEASE_PREFIX)).map((n) => join(cfg.releases, n))
|
|
237
|
+
.sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs);
|
|
238
|
+
const kept = new Set(keep);
|
|
239
|
+
const removed = [];
|
|
240
|
+
for (const dir of releases) {
|
|
241
|
+
if (kept.has(dir))
|
|
242
|
+
continue;
|
|
243
|
+
if (kept.size < KEEP_RELEASES) {
|
|
244
|
+
kept.add(dir);
|
|
245
|
+
continue;
|
|
246
|
+
}
|
|
247
|
+
rmSync(dir, { recursive: true, force: true });
|
|
248
|
+
removed.push(dir);
|
|
249
|
+
}
|
|
250
|
+
return removed;
|
|
251
|
+
}
|
|
252
|
+
function acquireLock(cfg) {
|
|
253
|
+
const lock = join(cfg.stateDir, "updater.lock");
|
|
254
|
+
if (existsSync(lock) && Date.now() - statSync(lock).mtimeMs > LOCK_STALE_MS)
|
|
255
|
+
unlinkSync(lock);
|
|
256
|
+
const fd = openSync(lock, "wx", 0o600);
|
|
257
|
+
writeFileSync(fd, String(process.pid));
|
|
258
|
+
closeSync(fd);
|
|
259
|
+
return () => { try {
|
|
260
|
+
unlinkSync(lock);
|
|
261
|
+
}
|
|
262
|
+
catch { /* déjà retiré */ } };
|
|
263
|
+
}
|
|
264
|
+
/** Traite une demande si présente. Renvoie l'état final (ou null si rien à faire). */
|
|
265
|
+
export async function runOnce(cfg, allowedUids) {
|
|
266
|
+
let release;
|
|
267
|
+
try {
|
|
268
|
+
release = acquireLock(cfg);
|
|
269
|
+
}
|
|
270
|
+
catch {
|
|
271
|
+
return null;
|
|
272
|
+
} // une mise à jour est déjà en cours
|
|
273
|
+
let target;
|
|
274
|
+
let from;
|
|
275
|
+
const set = (status, message) => writeStatus(cfg, { status, target, from, ...(message ? { message } : {}) });
|
|
276
|
+
try {
|
|
277
|
+
const request = takeRequest(cfg, allowedUids);
|
|
278
|
+
if (!request)
|
|
279
|
+
return null;
|
|
280
|
+
target = request.version;
|
|
281
|
+
const previous = existsSync(cfg.current) ? readlinkSync(cfg.current) : null;
|
|
282
|
+
from = previous ? releaseVersion(previous) ?? undefined : undefined;
|
|
283
|
+
const latest = await latestVersion(cfg);
|
|
284
|
+
if (target !== latest)
|
|
285
|
+
throw new Error(`Seule la dernière version publiée (${latest}) peut être installée.`);
|
|
286
|
+
if (from && !newer(target, from))
|
|
287
|
+
throw new Error(`La version ${target} n'est pas plus récente que ${from}.`);
|
|
288
|
+
const dir = buildRelease(cfg, target, (p) => set(p));
|
|
289
|
+
set("switching");
|
|
290
|
+
pointCurrent(cfg, dir);
|
|
291
|
+
try {
|
|
292
|
+
set("restarting");
|
|
293
|
+
run(cfg.systemctl, ["restart", cfg.unit], { timeoutMs: 120_000 });
|
|
294
|
+
set("verifying");
|
|
295
|
+
if (!await waitServing(cfg, target))
|
|
296
|
+
throw new Error(`La version ${target} n'a pas répondu après le redémarrage.`);
|
|
297
|
+
}
|
|
298
|
+
catch (error) {
|
|
299
|
+
if (!previous)
|
|
300
|
+
throw error;
|
|
301
|
+
set("rolling-back", error.message);
|
|
302
|
+
pointCurrent(cfg, previous);
|
|
303
|
+
try {
|
|
304
|
+
run(cfg.systemctl, ["restart", cfg.unit], { timeoutMs: 120_000 });
|
|
305
|
+
}
|
|
306
|
+
catch { /* état rapporté ci-dessous */ }
|
|
307
|
+
const back = from ? await waitServing(cfg, from) : false;
|
|
308
|
+
set("rolled-back", `${error.message} Retour à ${from ?? "la release précédente"}${back ? "" : " (vérifier le service)"}.`);
|
|
309
|
+
return readStatus(cfg);
|
|
310
|
+
}
|
|
311
|
+
try {
|
|
312
|
+
pruneReleases(cfg, [dir, ...(previous ? [previous] : [])]);
|
|
313
|
+
}
|
|
314
|
+
catch { /* nettoyage facultatif */ }
|
|
315
|
+
set("done");
|
|
316
|
+
return readStatus(cfg);
|
|
317
|
+
}
|
|
318
|
+
catch (error) {
|
|
319
|
+
set("error", error.message);
|
|
320
|
+
return readStatus(cfg);
|
|
321
|
+
}
|
|
322
|
+
finally {
|
|
323
|
+
release();
|
|
324
|
+
}
|
|
325
|
+
}
|
|
326
|
+
// ---------- Installation (root) ----------
|
|
327
|
+
function unitFiles(cfg, script, configPath) {
|
|
328
|
+
return {
|
|
329
|
+
"cogitator-updater.service": `[Unit]
|
|
330
|
+
Description=Cogitator updater (installs a published release requested from the web UI)
|
|
331
|
+
After=network-online.target
|
|
332
|
+
Wants=network-online.target
|
|
333
|
+
|
|
334
|
+
[Service]
|
|
335
|
+
Type=oneshot
|
|
336
|
+
ExecStart=${process.execPath} ${script} run --config ${configPath}
|
|
337
|
+
Environment=PATH=${dirname(process.execPath)}:/usr/local/bin:/usr/bin:/bin
|
|
338
|
+
TimeoutStartSec=20min
|
|
339
|
+
NoNewPrivileges=true
|
|
340
|
+
PrivateTmp=true
|
|
341
|
+
`,
|
|
342
|
+
"cogitator-updater.path": `[Unit]
|
|
343
|
+
Description=Watch for Cogitator update requests
|
|
344
|
+
|
|
345
|
+
[Path]
|
|
346
|
+
PathExists=${join(cfg.stateDir, "inbox", "request.json")}
|
|
347
|
+
Unit=cogitator-updater.service
|
|
348
|
+
|
|
349
|
+
[Install]
|
|
350
|
+
WantedBy=multi-user.target
|
|
351
|
+
`,
|
|
352
|
+
};
|
|
353
|
+
}
|
|
354
|
+
export function install(cfg, configPath = DEFAULT_CONFIG, opts = {}) {
|
|
355
|
+
const done = [];
|
|
356
|
+
const gid = Number(spawnSync("id", ["-g", cfg.user], { encoding: "utf8" }).stdout.trim());
|
|
357
|
+
if (!Number.isInteger(gid))
|
|
358
|
+
throw new Error(`Compte inconnu : ${cfg.user}`);
|
|
359
|
+
const installDir = opts.installDir ?? INSTALL_DIR;
|
|
360
|
+
mkdirSync(installDir, { recursive: true, mode: 0o755 });
|
|
361
|
+
const script = join(installDir, "cogitator-updater.mjs");
|
|
362
|
+
copyFileSync(fileURLToPath(import.meta.url), script);
|
|
363
|
+
chmodSync(script, 0o755);
|
|
364
|
+
done.push(script);
|
|
365
|
+
writeFileSync(configPath, JSON.stringify(cfg, null, 2) + "\n", { mode: 0o644 });
|
|
366
|
+
done.push(configPath);
|
|
367
|
+
mkdirSync(cfg.stateDir, { recursive: true, mode: 0o755 });
|
|
368
|
+
chmodSync(cfg.stateDir, 0o755);
|
|
369
|
+
const inbox = join(cfg.stateDir, "inbox");
|
|
370
|
+
mkdirSync(inbox, { recursive: true });
|
|
371
|
+
// Le compte du service peut déposer une demande, sans lister ni lire le dossier.
|
|
372
|
+
chownSync(inbox, opts.owner ?? 0, gid);
|
|
373
|
+
chmodSync(inbox, 0o730);
|
|
374
|
+
if (!existsSync(join(cfg.stateDir, "status.json")))
|
|
375
|
+
writeStatus(cfg, { status: "idle" });
|
|
376
|
+
done.push(cfg.stateDir);
|
|
377
|
+
if (opts.systemd !== false) {
|
|
378
|
+
const dir = opts.systemdDir ?? SYSTEMD_DIR;
|
|
379
|
+
for (const [name, body] of Object.entries(unitFiles(cfg, script, configPath))) {
|
|
380
|
+
writeFileSync(join(dir, name), body, { mode: 0o644 });
|
|
381
|
+
done.push(join(dir, name));
|
|
382
|
+
}
|
|
383
|
+
run(cfg.systemctl, ["daemon-reload"]);
|
|
384
|
+
run(cfg.systemctl, ["enable", "--now", "cogitator-updater.path"]);
|
|
385
|
+
}
|
|
386
|
+
return done;
|
|
387
|
+
}
|
|
388
|
+
function parseArgs(argv) {
|
|
389
|
+
const [cmd = "help", ...rest] = argv;
|
|
390
|
+
const flags = {};
|
|
391
|
+
for (let i = 0; i < rest.length; i++) {
|
|
392
|
+
const a = rest[i];
|
|
393
|
+
if (!a.startsWith("--"))
|
|
394
|
+
throw new Error(`Argument inattendu : ${a}`);
|
|
395
|
+
if (a === "--no-systemd") {
|
|
396
|
+
flags["no-systemd"] = "1";
|
|
397
|
+
continue;
|
|
398
|
+
}
|
|
399
|
+
const [k, v] = a.includes("=") ? a.slice(2).split(/=(.*)/s) : [a.slice(2), rest[++i] ?? ""];
|
|
400
|
+
flags[k] = v;
|
|
401
|
+
}
|
|
402
|
+
return { cmd, flags };
|
|
403
|
+
}
|
|
404
|
+
const USAGE = `cogitator-updater <install|run|status|uninstall> [options]
|
|
405
|
+
install --user cogitator --unit cogitator.service --home /var/lib/cogitator --port 5320
|
|
406
|
+
[--releases /opt/cogitator/releases] [--current /opt/cogitator/current] [--state-dir /var/lib/cogitator-updater]
|
|
407
|
+
[--config ${DEFAULT_CONFIG}] [--no-systemd] [--install-dir ${INSTALL_DIR}]
|
|
408
|
+
run [--config ${DEFAULT_CONFIG}] traite une demande en attente (lancé par systemd)
|
|
409
|
+
status [--config ${DEFAULT_CONFIG}]
|
|
410
|
+
uninstall [--config ${DEFAULT_CONFIG}]`;
|
|
411
|
+
async function main(argv) {
|
|
412
|
+
const { cmd, flags } = parseArgs(argv);
|
|
413
|
+
const configPath = flags.config || DEFAULT_CONFIG;
|
|
414
|
+
if (cmd === "install") {
|
|
415
|
+
if (process.getuid?.() !== 0)
|
|
416
|
+
throw new Error("install doit être lancé en root (sudo).");
|
|
417
|
+
const cfg = defaults({
|
|
418
|
+
...(flags.user ? { user: flags.user } : {}), ...(flags.unit ? { unit: flags.unit } : {}), ...(flags.home ? { home: flags.home } : {}),
|
|
419
|
+
...(flags.port ? { port: Number(flags.port) } : {}), ...(flags.releases ? { releases: flags.releases } : {}),
|
|
420
|
+
...(flags.current ? { current: flags.current } : {}), ...(flags["state-dir"] ? { stateDir: flags["state-dir"] } : {}),
|
|
421
|
+
...(flags.systemctl ? { systemctl: flags.systemctl } : {}), ...(flags.npm ? { npm: flags.npm } : {}),
|
|
422
|
+
});
|
|
423
|
+
if (!Number.isInteger(cfg.port) || cfg.port <= 0)
|
|
424
|
+
throw new Error("--port invalide");
|
|
425
|
+
for (const line of install(cfg, configPath, { systemd: !("no-systemd" in flags), ...(flags["install-dir"] ? { installDir: flags["install-dir"] } : {}) }))
|
|
426
|
+
console.log(` ✓ ${line}`);
|
|
427
|
+
console.log("cogitator-updater installé. Le bouton « Mettre à jour » de Cogitator l'utilisera automatiquement.");
|
|
428
|
+
return 0;
|
|
429
|
+
}
|
|
430
|
+
if (cmd === "run") {
|
|
431
|
+
const cfg = loadConfig(configPath);
|
|
432
|
+
const uid = uidOf(cfg.user);
|
|
433
|
+
const result = await runOnce(cfg, [0, ...(uid !== null ? [uid] : [])]);
|
|
434
|
+
if (result)
|
|
435
|
+
console.log(`${result.status}${result.target ? ` ${result.target}` : ""}${result.message ? ` — ${result.message}` : ""}`);
|
|
436
|
+
return result && (result.status === "error" || result.status === "rolled-back") ? 1 : 0;
|
|
437
|
+
}
|
|
438
|
+
if (cmd === "status") {
|
|
439
|
+
console.log(JSON.stringify(readStatus(loadConfig(configPath)), null, 2));
|
|
440
|
+
return 0;
|
|
441
|
+
}
|
|
442
|
+
if (cmd === "uninstall") {
|
|
443
|
+
if (process.getuid?.() !== 0)
|
|
444
|
+
throw new Error("uninstall doit être lancé en root (sudo).");
|
|
445
|
+
const cfg = loadConfig(configPath);
|
|
446
|
+
spawnSync(cfg.systemctl, ["disable", "--now", "cogitator-updater.path"]);
|
|
447
|
+
for (const name of ["cogitator-updater.service", "cogitator-updater.path"])
|
|
448
|
+
rmSync(join(SYSTEMD_DIR, name), { force: true });
|
|
449
|
+
spawnSync(cfg.systemctl, ["daemon-reload"]);
|
|
450
|
+
rmSync(cfg.stateDir, { recursive: true, force: true });
|
|
451
|
+
rmSync(INSTALL_DIR, { recursive: true, force: true });
|
|
452
|
+
rmSync(configPath, { force: true });
|
|
453
|
+
console.log("cogitator-updater désinstallé (les releases sous /opt sont conservées).");
|
|
454
|
+
return 0;
|
|
455
|
+
}
|
|
456
|
+
console.log(USAGE);
|
|
457
|
+
return cmd === "help" ? 0 : 2;
|
|
458
|
+
}
|
|
459
|
+
const invoked = process.argv[1] && (() => { try {
|
|
460
|
+
return statSync(process.argv[1]).isFile() && basename(process.argv[1]).startsWith("cogitator-updater");
|
|
461
|
+
}
|
|
462
|
+
catch {
|
|
463
|
+
return false;
|
|
464
|
+
} })();
|
|
465
|
+
if (invoked) {
|
|
466
|
+
main(process.argv.slice(2)).then((code) => { process.exitCode = code; }, (error) => { console.error(`[cogitator-updater] ${error.message}`); process.exitCode = 1; });
|
|
467
|
+
}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@ignitionai/cogitator",
|
|
3
|
-
"version": "0.
|
|
3
|
+
"version": "0.8.0",
|
|
4
4
|
"description": "A web control panel for pi: composable agents, workspaces, interactive conversations, and scheduled tasks. A pi package.",
|
|
5
5
|
"type": "module",
|
|
6
6
|
"keywords": [
|
|
@@ -23,7 +23,8 @@
|
|
|
23
23
|
"node": ">=22.19.0"
|
|
24
24
|
},
|
|
25
25
|
"bin": {
|
|
26
|
-
"cogitator": "dist/src/cli.js"
|
|
26
|
+
"cogitator": "dist/src/cli.js",
|
|
27
|
+
"cogitator-updater": "dist/src/updater/cogitator-updater.js"
|
|
27
28
|
},
|
|
28
29
|
"files": [
|
|
29
30
|
"dist/src",
|