@parall/daemon 1.29.3 → 1.31.0

package/dist/updater.js

@@ -0,0 +1,409 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as https from "node:https";
+import * as http from "node:http";
+import { createHash } from "node:crypto";
+import { verifyManifestSignature, semverCompare, } from "./updater-manifest.js";
+const UPDATE_EXIT_CODE = 42;
+// Ed25519 public key for verifying daemon bundle manifests.
+// The corresponding private key lives in GitHub Actions secrets (DAEMON_BUNDLE_SIGNING_KEY).
+// Placeholder — replaced with the real key when the CI signing pipeline is set up.
+const SIGNING_PUBLIC_KEY = process.env.PRLL_DAEMON_SIGNING_PUBLIC_KEY ?? "";
+export class DaemonUpdater {
+    bundleDir;
+    cdnBaseUrl;
+    log;
+    signingEnabled;
+    updating = false;
+    periodicTimer = null;
+    constructor(bundleDir, cdnBaseUrl, log, signingEnabled) {
+        this.bundleDir = bundleDir;
+        this.cdnBaseUrl = cdnBaseUrl;
+        this.log = log;
+        this.signingEnabled = signingEnabled;
+    }
+    // --- Public API ---
+    /**
+     * Start periodic update checks. Call once after supervisor bootstrap.
+     */
+    startPeriodicCheck(intervalMs) {
+        if (intervalMs <= 0 || this.periodicTimer)
+            return;
+        this.periodicTimer = setInterval(() => {
+            this.checkAndApply().catch((err) => {
+                this.log.warn(`periodic update check failed: ${String(err)}`);
+            });
+        }, intervalMs);
+        this.periodicTimer.unref?.();
+    }
+    stopPeriodicCheck() {
+        if (this.periodicTimer) {
+            clearInterval(this.periodicTimer);
+            this.periodicTimer = null;
+        }
+    }
+    /**
+     * Check CDN for a newer version. Returns true if update was applied
+     * (caller should exit for service manager restart).
+     */
+    async checkAndApply(targetVersion) {
+        if (this.updating)
+            return false;
+        this.updating = true;
+        try {
+            return await this.doUpdate(targetVersion);
+        }
+        catch (err) {
+            this.log.warn(`update check failed: ${String(err)}`);
+            return false;
+        }
+        finally {
+            this.updating = false;
+        }
+    }
+    /**
+     * Handle WS-triggered update. Adds jitter for non-mandatory updates.
+     */
+    async triggerUpdate(targetVersion, mandatory) {
+        if (!mandatory) {
+            const jitter = Math.random() * 180_000;
+            await new Promise((r) => setTimeout(r, jitter));
+        }
+        return this.checkAndApply(targetVersion);
+    }
+    /**
+     * Check if we need to roll back from a failed update.
+     * Call on every daemon startup, before bootstrap.
+     * Returns true if rollback was performed (caller should exit immediately).
+     */
+    checkRollback() {
+        const state = this.loadUpdateState();
+        const current = this.loadLocalManifest();
+        if (!state || !current)
+            return false;
+        if (!state.pending_version || state.pending_version !== current.version)
+            return false;
+        state.boot_count = (state.boot_count ?? 0) + 1;
+        this.saveUpdateState(state);
+        if (state.boot_count < 3)
+            return false;
+        if (!state.previous_version)
+            return false;
+        const previousDir = path.join(this.bundleDir, "versions", state.previous_version);
+        if (!fs.existsSync(previousDir))
+            return false;
+        this.log.warn(`rollback: ${current.version} failed ${state.boot_count} boots, reverting to ${state.previous_version}`);
+        if (process.platform === "win32") {
+            // Windows: copy previous version files into current dir (no symlinks)
+            const currentDir = path.join(this.bundleDir, "current");
+            if (fs.existsSync(currentDir)) {
+                for (const file of fs.readdirSync(currentDir)) {
+                    fs.unlinkSync(path.join(currentDir, file));
+                }
+            }
+            fs.mkdirSync(currentDir, { recursive: true });
+            for (const file of fs.readdirSync(previousDir)) {
+                fs.copyFileSync(path.join(previousDir, file), path.join(currentDir, file));
+            }
+        }
+        else {
+            this.swapSymlink(state.previous_version);
+        }
+        state.confirmed_version = state.previous_version;
+        state.pending_version = undefined;
+        state.boot_count = 0;
+        state.rollback_from = current.version;
+        state.rollback_at = new Date().toISOString();
+        this.saveUpdateState(state);
+        return true;
+    }
+    /**
+     * Confirm the current version after successful health check.
+     * Clears pending state so rollback won't trigger.
+     */
+    confirmVersion() {
+        const current = this.loadLocalManifest();
+        if (!current)
+            return;
+        const state = this.loadUpdateState() ?? {};
+        state.confirmed_version = current.version;
+        state.confirmed_at = new Date().toISOString();
+        state.pending_version = undefined;
+        state.boot_count = 0;
+        this.saveUpdateState(state);
+        this.log.info(`update: confirmed version ${current.version}`);
+    }
+    /**
+     * Get the current local manifest version (for heartbeat reporting).
+     */
+    getLocalVersion() {
+        return this.loadLocalManifest()?.version;
+    }
+    /**
+     * Check CDN for available update without downloading.
+     * Returns remote version info for CLI --check display.
+     */
+    async checkAvailable() {
+        const local = this.loadLocalManifest();
+        const manifestUrl = `${this.cdnBaseUrl}/latest/manifest.json`;
+        try {
+            const remoteJson = await this.httpGet(manifestUrl);
+            const remote = JSON.parse(remoteJson);
+            const current = local?.version;
+            if (current) {
+                const cmp = semverCompare(remote.version, current);
+                return { available: cmp !== null && cmp > 0, currentVersion: current, remoteVersion: remote.version };
+            }
+            return { available: true, remoteVersion: remote.version };
+        }
+        catch {
+            return { available: false, currentVersion: local?.version };
+        }
+    }
+    // --- Internal ---
+    async doUpdate(targetVersion) {
+        const local = this.loadLocalManifest();
+        const manifestUrl = targetVersion
+            ? `${this.cdnBaseUrl}/${targetVersion}/manifest.json`
+            : `${this.cdnBaseUrl}/latest/manifest.json`;
+        let remoteJson;
+        try {
+            remoteJson = await this.httpGet(manifestUrl);
+        }
+        catch (err) {
+            this.log.warn(`update: failed to fetch manifest from ${manifestUrl}: ${String(err)}`);
+            return false;
+        }
+        let remote;
+        try {
+            remote = JSON.parse(remoteJson);
+        }
+        catch {
+            this.log.warn("update: failed to parse remote manifest");
+            return false;
+        }
+        // Reject same or older versions (downgrade protection)
+        if (local) {
+            const cmp = semverCompare(remote.version, local.version);
+            if (cmp === null || cmp <= 0)
+                return false;
+        }
+        // Skip versions we already rolled back from
+        const state = this.loadUpdateState();
+        if (state?.rollback_from === remote.version) {
+            this.log.info(`update: skipping ${remote.version} (previously rolled back)`);
+            return false;
+        }
+        // Verify Ed25519 signature (fail-closed: reject when key is missing)
+        if (this.signingEnabled) {
+            if (!SIGNING_PUBLIC_KEY) {
+                this.log.error("update: signing enabled but PRLL_DAEMON_SIGNING_PUBLIC_KEY is empty — rejecting update");
+                return false;
+            }
+            if (!verifyManifestSignature(remote, SIGNING_PUBLIC_KEY)) {
+                this.log.error(`update: signature verification failed for ${remote.version}`);
+                return false;
+            }
+        }
+        // Download all files to staging directory
+        const stagingDir = path.join(this.bundleDir, "staging");
+        this.cleanDir(stagingDir);
+        fs.mkdirSync(stagingDir, { recursive: true });
+        for (const [filename, meta] of Object.entries(remote.files)) {
+            const filePath = path.join(stagingDir, filename);
+            const fileUrl = `${this.cdnBaseUrl}/${remote.version}/${filename}`;
+            try {
+                await this.downloadFile(fileUrl, filePath);
+            }
+            catch (err) {
+                this.log.error(`update: download failed for ${filename}: ${String(err)}`);
+                this.cleanDir(stagingDir);
+                return false;
+            }
+            // Verify sha256
+            const content = fs.readFileSync(filePath);
+            const hash = createHash("sha256").update(content).digest("hex");
+            if (hash !== meta.sha256) {
+                this.log.error(`update: sha256 mismatch for ${filename} (expected ${meta.sha256}, got ${hash})`);
+                this.cleanDir(stagingDir);
+                return false;
+            }
+            // Verify size
+            if (content.length !== meta.size) {
+                this.log.error(`update: size mismatch for ${filename} (expected ${meta.size}, got ${content.length})`);
+                this.cleanDir(stagingDir);
+                return false;
+            }
+        }
+        // Write manifest to staging
+        fs.writeFileSync(path.join(stagingDir, "manifest.json"), JSON.stringify(remote, null, 2));
+        // Atomic swap
+        this.atomicSwap(stagingDir, remote.version);
+        // Record pending update state
+        const newState = {
+            confirmed_version: local?.version ?? state?.confirmed_version,
+            previous_version: local?.version,
+            pending_version: remote.version,
+            pending_at: new Date().toISOString(),
+            boot_count: 0,
+        };
+        this.saveUpdateState(newState);
+        this.log.info(`update: ${local?.version ?? "unknown"} → ${remote.version} applied, restarting`);
+        return true;
+    }
+    atomicSwap(stagingDir, newVersion) {
+        const versionsDir = path.join(this.bundleDir, "versions");
+        const targetDir = path.join(versionsDir, newVersion);
+        const currentLink = path.join(this.bundleDir, "current");
+        fs.mkdirSync(versionsDir, { recursive: true });
+        // If target version dir already exists (partial previous attempt), remove it
+        if (fs.existsSync(targetDir)) {
+            fs.rmSync(targetDir, { recursive: true });
+        }
+        fs.renameSync(stagingDir, targetDir);
+        if (process.platform === "win32") {
+            // Windows: JS files aren't locked, copy directly.
+            // Clean old files first to avoid stale artifacts from previous versions.
+            const currentDir = currentLink;
+            if (fs.existsSync(currentDir)) {
+                for (const file of fs.readdirSync(currentDir)) {
+                    fs.unlinkSync(path.join(currentDir, file));
+                }
+            }
+            fs.mkdirSync(currentDir, { recursive: true });
+            for (const file of fs.readdirSync(targetDir)) {
+                fs.copyFileSync(path.join(targetDir, file), path.join(currentDir, file));
+            }
+        }
+        else {
+            // POSIX: atomic symlink swap
+            this.swapSymlink(newVersion);
+        }
+        // Prune old versions (keep current + previous)
+        this.pruneOldVersions(versionsDir, newVersion);
+    }
+    swapSymlink(version) {
+        const currentLink = path.join(this.bundleDir, "current");
+        const tmpLink = `${currentLink}.new`;
+        try {
+            fs.unlinkSync(tmpLink);
+        }
+        catch { }
+        fs.symlinkSync(`versions/${version}`, tmpLink);
+        fs.renameSync(tmpLink, currentLink);
+    }
+    pruneOldVersions(versionsDir, currentVersion) {
+        const state = this.loadUpdateState();
+        const keep = new Set([currentVersion]);
+        if (state?.previous_version)
+            keep.add(state.previous_version);
+        if (state?.confirmed_version)
+            keep.add(state.confirmed_version);
+        try {
+            for (const entry of fs.readdirSync(versionsDir)) {
+                if (!keep.has(entry)) {
+                    fs.rmSync(path.join(versionsDir, entry), { recursive: true });
+                }
+            }
+        }
+        catch {
+            // best-effort cleanup
+        }
+    }
+    // --- Manifest & State I/O ---
+    loadLocalManifest() {
+        const currentDir = path.join(this.bundleDir, "current");
+        const manifestPath = path.join(currentDir, "manifest.json");
+        try {
+            return JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+        }
+        catch {
+            return null;
+        }
+    }
+    loadUpdateState() {
+        const statePath = path.join(this.bundleDir, "update-state.json");
+        try {
+            return JSON.parse(fs.readFileSync(statePath, "utf-8"));
+        }
+        catch {
+            return null;
+        }
+    }
+    saveUpdateState(state) {
+        const statePath = path.join(this.bundleDir, "update-state.json");
+        fs.mkdirSync(path.dirname(statePath), { recursive: true });
+        fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+    }
+    // --- HTTP helpers ---
+    httpGet(url, maxRedirects = 5) {
+        return new Promise((resolve, reject) => {
+            const mod = url.startsWith("https") ? https : http;
+            const req = mod.get(url, (res) => {
+                if (res.statusCode === 301 || res.statusCode === 302) {
+                    if (res.headers.location && maxRedirects > 0) {
+                        this.httpGet(res.headers.location, maxRedirects - 1).then(resolve, reject);
+                        return;
+                    }
+                    res.resume();
+                    reject(new Error(`too many redirects or missing location for ${url}`));
+                    return;
+                }
+                if (res.statusCode !== 200) {
+                    res.resume();
+                    reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+                    return;
+                }
+                const chunks = [];
+                res.on("data", (chunk) => chunks.push(chunk));
+                res.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+                res.on("error", reject);
+            });
+            req.on("error", reject);
+            req.setTimeout(30_000, () => {
+                req.destroy(new Error(`timeout fetching ${url}`));
+            });
+        });
+    }
+    downloadFile(url, dest, maxRedirects = 5) {
+        return new Promise((resolve, reject) => {
+            const mod = url.startsWith("https") ? https : http;
+            const req = mod.get(url, (res) => {
+                if (res.statusCode === 301 || res.statusCode === 302) {
+                    if (res.headers.location && maxRedirects > 0) {
+                        this.downloadFile(res.headers.location, dest, maxRedirects - 1).then(resolve, reject);
+                        return;
+                    }
+                    res.resume();
+                    reject(new Error(`too many redirects or missing location for ${url}`));
+                    return;
+                }
+                if (res.statusCode !== 200) {
+                    res.resume();
+                    reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+                    return;
+                }
+                const file = fs.createWriteStream(dest);
+                res.pipe(file);
+                file.on("finish", () => {
+                    file.close();
+                    resolve();
+                });
+                file.on("error", (err) => {
+                    fs.unlinkSync(dest);
+                    reject(err);
+                });
+            });
+            req.on("error", reject);
+            req.setTimeout(120_000, () => {
+                req.destroy(new Error(`timeout downloading ${url}`));
+            });
+        });
+    }
+    cleanDir(dir) {
+        try {
+            fs.rmSync(dir, { recursive: true });
+        }
+        catch { }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parall/daemon",
-  "version": "1.29.3",
+  "version": "1.31.0",
   "description": "Parall local agent runtime — daemon supervisor + bridge runtimes, bundled as standalone JS files",
   "license": "MIT",
   "repository": {
@@ -29,11 +29,11 @@
     "dist"
   ],
   "dependencies": {
-    "@parall/agent-core": "1.29.3",
-    "@parall/sdk": "1.29.3",
-    "@parall/claude-agent": "1.29.3",
-    "@parall/codex-agent": "1.29.3",
-    "@parall/openclaw-agent": "1.29.3"
+    "@parall/agent-core": "1.31.0",
+    "@parall/sdk": "1.31.0",
+    "@parall/claude-agent": "1.31.0",
+    "@parall/codex-agent": "1.31.0",
+    "@parall/openclaw-agent": "1.31.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",