@parall/daemon 1.30.0 → 1.31.0

package/dist/updater-manifest.js

@@ -0,0 +1,94 @@
+import { verify } from "node:crypto";
+/**
+ * Recursively sort all object keys at every depth for deterministic JSON output.
+ * Arrays preserve order; primitives pass through.
+ */
+export function canonicalize(obj) {
+    if (Array.isArray(obj))
+        return obj.map(canonicalize);
+    if (obj !== null && typeof obj === "object") {
+        const sorted = {};
+        for (const k of Object.keys(obj).sort()) {
+            sorted[k] = canonicalize(obj[k]);
+        }
+        return sorted;
+    }
+    return obj;
+}
+/**
+ * Verify the Ed25519 signature of a remote manifest.
+ * Signs canonical JSON of all fields except `signature`.
+ */
+export function verifyManifestSignature(manifest, publicKey) {
+    const { signature, ...rest } = manifest;
+    const canonical = JSON.stringify(canonicalize(rest));
+    try {
+        return verify(null, Buffer.from(canonical), publicKey, Buffer.from(signature, "base64"));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Compare two semver strings (including prerelease tags). Returns:
+ *   -1 if a < b
+ *    0 if a == b
+ *    1 if a > b
+ *   null if either is not valid semver
+ *
+ * Prerelease ordering follows SemVer 2.0: a version with prerelease has
+ * lower precedence than the same version without prerelease. Prerelease
+ * identifiers are compared lexicographically when both present.
+ */
+export function semverCompare(a, b) {
+    const pa = parseSemver(a);
+    const pb = parseSemver(b);
+    if (!pa || !pb)
+        return null;
+    for (let i = 0; i < 3; i++) {
+        if (pa.nums[i] < pb.nums[i])
+            return -1;
+        if (pa.nums[i] > pb.nums[i])
+            return 1;
+    }
+    // Same major.minor.patch — compare prerelease:
+    // no prerelease > has prerelease (per SemVer §11)
+    if (!pa.pre && !pb.pre)
+        return 0;
+    if (!pa.pre)
+        return 1;
+    if (!pb.pre)
+        return -1;
+    // Both have prerelease: lexicographic comparison
+    if (pa.pre < pb.pre)
+        return -1;
+    if (pa.pre > pb.pre)
+        return 1;
+    return 0;
+}
+function parseSemver(v) {
+    // Split off prerelease at the first hyphen in the patch component.
+    // e.g. "0.0.0-staging.abc1234" → major=0, minor=0, patch="0", pre="staging.abc1234"
+    const parts = v.split(".");
+    if (parts.length < 3)
+        return null;
+    // Rejoin any dots beyond the first two (prerelease may contain dots)
+    const major = Number(parts[0]);
+    const minor = Number(parts[1]);
+    const rest = parts.slice(2).join(".");
+    // Split patch from prerelease: "0-staging.abc" → patch="0", pre="staging.abc"
+    const hyphen = rest.indexOf("-");
+    let patchStr;
+    let pre;
+    if (hyphen >= 0) {
+        patchStr = rest.slice(0, hyphen);
+        pre = rest.slice(hyphen + 1);
+    }
+    else {
+        patchStr = rest;
+    }
+    const patch = Number(patchStr);
+    if (isNaN(major) || isNaN(minor) || isNaN(patch))
+        return null;
+    return { nums: [major, minor, patch], pre };
+}

package/dist/updater.d.ts

@@ -0,0 +1,60 @@
+import type { GatewayLogger } from "@parall/agent-core";
+import { type LocalManifest } from "./updater-manifest.js";
+export declare class DaemonUpdater {
+    private readonly bundleDir;
+    private readonly cdnBaseUrl;
+    private readonly log;
+    private readonly signingEnabled;
+    private updating;
+    private periodicTimer;
+    constructor(bundleDir: string, cdnBaseUrl: string, log: GatewayLogger, signingEnabled: boolean);
+    /**
+     * Start periodic update checks. Call once after supervisor bootstrap.
+     */
+    startPeriodicCheck(intervalMs: number): void;
+    stopPeriodicCheck(): void;
+    /**
+     * Check CDN for a newer version. Returns true if update was applied
+     * (caller should exit for service manager restart).
+     */
+    checkAndApply(targetVersion?: string): Promise<boolean>;
+    /**
+     * Handle WS-triggered update. Adds jitter for non-mandatory updates.
+     */
+    triggerUpdate(targetVersion: string, mandatory: boolean): Promise<boolean>;
+    /**
+     * 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(): boolean;
+    /**
+     * Confirm the current version after successful health check.
+     * Clears pending state so rollback won't trigger.
+     */
+    confirmVersion(): void;
+    /**
+     * Get the current local manifest version (for heartbeat reporting).
+     */
+    getLocalVersion(): string | undefined;
+    /**
+     * Check CDN for available update without downloading.
+     * Returns remote version info for CLI --check display.
+     */
+    checkAvailable(): Promise<{
+        available: boolean;
+        currentVersion?: string;
+        remoteVersion?: string;
+    }>;
+    private doUpdate;
+    private atomicSwap;
+    private swapSymlink;
+    private pruneOldVersions;
+    loadLocalManifest(): LocalManifest | null;
+    private loadUpdateState;
+    private saveUpdateState;
+    private httpGet;
+    private downloadFile;
+    private cleanDir;
+}
+//# sourceMappingURL=updater.d.ts.map

package/dist/updater.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updater.d.ts","sourceRoot":"","sources":["../src/updater.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAEL,KAAK,aAAa,EAGnB,MAAM,uBAAuB,CAAC;AAoB/B,qBAAa,aAAa;IAKtB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAPjC,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,aAAa,CAA+B;gBAGjC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,aAAa,EAClB,cAAc,EAAE,OAAO;IAK1C;;OAEG;IACH,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAU5C,iBAAiB,IAAI,IAAI;IAOzB;;;OAGG;IACG,aAAa,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAa7D;;OAEG;IACG,aAAa,CAAC,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAQhF;;;;OAIG;IACH,aAAa,IAAI,OAAO;IA6CxB;;;OAGG;IACH,cAAc,IAAI,IAAI;IAYtB;;OAEG;IACH,eAAe,IAAI,MAAM,GAAG,SAAS;IAIrC;;;OAGG;IACG,cAAc,IAAI,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;YAmB1F,QAAQ;IAqGtB,OAAO,CAAC,UAAU;IAmClB,OAAO,CAAC,WAAW;IAUnB,OAAO,CAAC,gBAAgB;IAmBxB,iBAAiB,IAAI,aAAa,GAAG,IAAI;IAUzC,OAAO,CAAC,eAAe;IASvB,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,OAAO;IA8Bf,OAAO,CAAC,YAAY;IAoCpB,OAAO,CAAC,QAAQ;CAKjB"}

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.30.0",
+  "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.30.0",
-    "@parall/sdk": "1.30.0",
-    "@parall/claude-agent": "1.30.0",
-    "@parall/codex-agent": "1.30.0",
-    "@parall/openclaw-agent": "1.30.0"
+    "@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",