@camstack/server 1.2.94 → 1.2.95

package/dist/launcher-framework-swap.js

@@ -1,408 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writePendingFrameworkSwap = writePendingFrameworkSwap;
-exports.applyPendingFrameworkSwap = applyPendingFrameworkSwap;
-exports.rollbackUnconfirmedFrameworkSwap = rollbackUnconfirmedFrameworkSwap;
-exports.confirmFrameworkSwapHealthy = confirmFrameworkSwapHealthy;
-/**
- * Launcher zero-dep framework swap/rollback helpers.
- *
- * These run before @camstack/system is imported — zero @camstack imports.
- * Only node:fs + node:path. All writes are atomic (tmpfile+rename).
- * All reads tolerate missing/corrupt files (no-op result).
- */
-const fs = __importStar(require("node:fs"));
-const path = __importStar(require("node:path"));
-const lifecycle_journal_path_js_1 = require("./lifecycle-journal-path.js");
-// ---------------------------------------------------------------------------
-// Marker file names
-// ---------------------------------------------------------------------------
-const PENDING_SWAP_MARKER = '.pending-framework-swap.json';
-const SWAP_CONFIRM_MARKER = '.framework-swap-confirm.json';
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-/** Write a JSON file atomically via a tmp sibling + rename. */
-function writeJsonAtomic(filePath, value) {
-    const tmp = `${filePath}.tmp`;
-    fs.writeFileSync(tmp, JSON.stringify(value), 'utf-8');
-    fs.renameSync(tmp, filePath);
-}
-/** Read + parse JSON, returning null on any error (missing / corrupt). */
-function readJsonSafe(filePath) {
-    try {
-        return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-    }
-    catch {
-        return null;
-    }
-}
-/** Validate that a parsed value matches the PendingSwapMarker shape. */
-function isPendingSwapMarker(value) {
-    if (typeof value !== 'object' || value === null)
-        return false;
-    const v = value;
-    if (typeof v['jobId'] !== 'string')
-        return false;
-    if (typeof v['taskId'] !== 'string')
-        return false;
-    if (!Array.isArray(v['packages']))
-        return false;
-    for (const pkg of v['packages']) {
-        if (typeof pkg !== 'object' || pkg === null)
-            return false;
-        const p = pkg;
-        if (typeof p['name'] !== 'string')
-            return false;
-        if (typeof p['stagedPath'] !== 'string')
-            return false;
-        if (typeof p['backupPath'] !== 'string')
-            return false;
-    }
-    if (typeof v['requestedAtMs'] !== 'number')
-        return false;
-    if (v['schemaVersion'] !== 1)
-        return false;
-    return true;
-}
-/** Validate that a parsed value matches the SwapConfirmMarker shape. */
-function isSwapConfirmMarker(value) {
-    if (typeof value !== 'object' || value === null)
-        return false;
-    const v = value;
-    if (typeof v['jobId'] !== 'string')
-        return false;
-    if (typeof v['taskId'] !== 'string')
-        return false;
-    if (!Array.isArray(v['backups']))
-        return false;
-    for (const b of v['backups']) {
-        if (typeof b !== 'object' || b === null)
-            return false;
-        const entry = b;
-        if (typeof entry['name'] !== 'string')
-            return false;
-        if (typeof entry['backupPath'] !== 'string')
-            return false;
-        if (typeof entry['livePath'] !== 'string')
-            return false;
-    }
-    if (typeof v['appliedAtMs'] !== 'number')
-        return false;
-    if (typeof v['bootAttempts'] !== 'number')
-        return false;
-    if (v['schemaVersion'] !== 1)
-        return false;
-    return true;
-}
-/**
- * Patch a specific task inside a journal job file atomically.
- * Reads `<dataDir>/lifecycle/jobs/<jobId>.json`, updates tasks[taskId],
- * and writes back atomically. Silently no-ops on any read/write error.
- */
-function patchJournalTask(dataDir, jobId, taskId, patch) {
-    const jobFile = path.join((0, lifecycle_journal_path_js_1.lifecycleJobsDir)(dataDir), `${jobId}.json`);
-    const raw = readJsonSafe(jobFile);
-    if (typeof raw !== 'object' || raw === null)
-        return;
-    const job = raw;
-    const tasks = job['tasks'];
-    if (!Array.isArray(tasks))
-        return;
-    const updatedTasks = tasks.map((task) => {
-        if (typeof task !== 'object' || task === null)
-            return task;
-        const t = task;
-        if (t['taskId'] !== taskId)
-            return task;
-        const updated = { ...t, phase: patch.phase };
-        if (patch.error !== undefined)
-            updated['error'] = patch.error;
-        if (patch.finishedAtMs !== undefined)
-            updated['finishedAtMs'] = patch.finishedAtMs;
-        return updated;
-    });
-    try {
-        writeJsonAtomic(jobFile, { ...job, tasks: updatedTasks });
-    }
-    catch {
-        // journal patch is best-effort — never crash the launcher
-    }
-}
-/** Copy a directory tree cross-device (fallback for EXDEV rename errors). */
-function moveDirCrossDevice(src, dest) {
-    fs.cpSync(src, dest, { recursive: true });
-    fs.rmSync(src, { recursive: true, force: true });
-}
-/**
- * Write the `.pending-framework-swap.json` marker atomically.
- * Co-located with the reader (`applyPendingFrameworkSwap`) for symmetry.
- * Zero @camstack deps — this file runs before @camstack/system is imported.
- */
-function writePendingFrameworkSwap(dataDir, marker) {
-    const markerPath = path.join(dataDir, PENDING_SWAP_MARKER);
-    writeJsonAtomic(markerPath, marker);
-}
-/**
- * Apply a pending framework swap if a `.pending-framework-swap.json` marker
- * exists in `dataDir`. Swaps each listed package atomically:
- *   1. Backup: rename live → backupPath
- *   2. Swap: rename staged → live (EXDEV fallback: cpSync + rmSync)
- *
- * On any mid-loop failure: restores already-swapped packages, deletes the
- * marker, returns `{ applied: false }`.
- * On success: writes `.framework-swap-confirm.json`, patches the journal
- * task to `applied`, deletes the swap marker, returns `{ applied: true, jobId }`.
- */
-function applyPendingFrameworkSwap(dataDir, frameworkDir) {
-    if (!frameworkDir)
-        return { applied: false };
-    const markerPath = path.join(dataDir, PENDING_SWAP_MARKER);
-    if (!fs.existsSync(markerPath))
-        return { applied: false };
-    const raw = readJsonSafe(markerPath);
-    if (!isPendingSwapMarker(raw)) {
-        // malformed — delete to prevent blocking future updates
-        try {
-            fs.rmSync(markerPath, { force: true });
-        }
-        catch {
-            // ignore deletion error
-        }
-        return { applied: false };
-    }
-    const marker = raw;
-    const swapped = [];
-    for (const pkg of marker.packages) {
-        const livePath = path.join(frameworkDir, 'node_modules', pkg.name);
-        try {
-            // Step 1: backup live dir if it exists
-            if (fs.existsSync(livePath)) {
-                fs.mkdirSync(path.dirname(pkg.backupPath), { recursive: true });
-                fs.renameSync(livePath, pkg.backupPath);
-            }
-            // Step 2: move staged dir to live
-            try {
-                fs.mkdirSync(path.dirname(livePath), { recursive: true });
-                fs.renameSync(pkg.stagedPath, livePath);
-            }
-            catch (err) {
-                if (err.code === 'EXDEV') {
-                    fs.mkdirSync(path.dirname(livePath), { recursive: true });
-                    moveDirCrossDevice(pkg.stagedPath, livePath);
-                }
-                else {
-                    throw err;
-                }
-            }
-            swapped.push({ livePath, backupPath: pkg.backupPath });
-        }
-        catch {
-            // Restore all already-swapped packages
-            for (const done of swapped) {
-                try {
-                    if (fs.existsSync(done.livePath)) {
-                        fs.rmSync(done.livePath, { recursive: true, force: true });
-                    }
-                    if (fs.existsSync(done.backupPath)) {
-                        fs.mkdirSync(path.dirname(done.livePath), { recursive: true });
-                        fs.renameSync(done.backupPath, done.livePath);
-                    }
-                }
-                catch {
-                    // best-effort restore
-                }
-            }
-            // Delete the pending marker so the next boot doesn't retry a broken swap
-            try {
-                fs.rmSync(markerPath, { force: true });
-            }
-            catch {
-                // ignore
-            }
-            return { applied: false };
-        }
-    }
-    // All packages swapped successfully — write confirm marker
-    const backups = marker.packages.map((pkg) => ({
-        name: pkg.name,
-        backupPath: pkg.backupPath,
-        livePath: path.join(frameworkDir, 'node_modules', pkg.name),
-    }));
-    const confirmMarker = {
-        jobId: marker.jobId,
-        taskId: marker.taskId,
-        backups,
-        appliedAtMs: Date.now(),
-        bootAttempts: 0,
-        schemaVersion: 1,
-    };
-    // Write confirm marker — if this fails, restore everything and fail the apply
-    try {
-        writeJsonAtomic(path.join(dataDir, SWAP_CONFIRM_MARKER), confirmMarker);
-    }
-    catch {
-        // Confirm marker write failed — restore all swapped packages and fail the apply
-        for (const done of swapped) {
-            try {
-                if (fs.existsSync(done.livePath)) {
-                    fs.rmSync(done.livePath, { recursive: true, force: true });
-                }
-                if (fs.existsSync(done.backupPath)) {
-                    fs.mkdirSync(path.dirname(done.livePath), { recursive: true });
-                    fs.renameSync(done.backupPath, done.livePath);
-                }
-            }
-            catch {
-                // best-effort restore
-            }
-        }
-        // Delete the pending marker so the next boot doesn't retry
-        try {
-            fs.rmSync(markerPath, { force: true });
-        }
-        catch {
-            // ignore
-        }
-        return { applied: false };
-    }
-    // Patch journal task → applied (best-effort, doesn't fail the apply)
-    patchJournalTask(dataDir, marker.jobId, marker.taskId, { phase: 'applied' });
-    // Delete the swap marker
-    try {
-        fs.rmSync(markerPath, { force: true });
-    }
-    catch {
-        // ignore
-    }
-    return { applied: true, jobId: marker.jobId };
-}
-/**
- * Check for an unconfirmed framework swap on boot.
- *
- * - `bootAttempts === 0`: this is the probation boot. Increment to 1,
- *   rewrite the marker, return `{ rolledBack: false }`.
- * - `bootAttempts >= 1`: the previous probation boot crashed / didn't call
- *   `confirmFrameworkSwapHealthy`. Restore all backups, patch the journal
- *   task to `failed`, delete the confirm marker, return `{ rolledBack: true }`.
- */
-function rollbackUnconfirmedFrameworkSwap(dataDir, frameworkDir) {
-    if (!frameworkDir)
-        return { rolledBack: false };
-    const confirmPath = path.join(dataDir, SWAP_CONFIRM_MARKER);
-    if (!fs.existsSync(confirmPath))
-        return { rolledBack: false };
-    const raw = readJsonSafe(confirmPath);
-    if (!isSwapConfirmMarker(raw))
-        return { rolledBack: false };
-    const confirm = raw;
-    if (confirm.bootAttempts === 0) {
-        // Probation boot — increment attempts and let this boot proceed
-        const updated = { ...confirm, bootAttempts: 1 };
-        try {
-            writeJsonAtomic(confirmPath, updated);
-        }
-        catch {
-            // ignore write failure
-        }
-        return { rolledBack: false };
-    }
-    // bootAttempts >= 1: probation boot didn't become healthy — rollback
-    for (const backup of confirm.backups) {
-        try {
-            if (fs.existsSync(backup.livePath)) {
-                fs.rmSync(backup.livePath, { recursive: true, force: true });
-            }
-            if (fs.existsSync(backup.backupPath)) {
-                fs.mkdirSync(path.dirname(backup.livePath), { recursive: true });
-                fs.renameSync(backup.backupPath, backup.livePath);
-            }
-        }
-        catch {
-            // best-effort restore
-        }
-    }
-    patchJournalTask(dataDir, confirm.jobId, confirm.taskId, {
-        phase: 'failed',
-        error: 'framework update rolled back — boot did not become healthy',
-        finishedAtMs: Date.now(),
-    });
-    try {
-        fs.rmSync(confirmPath, { force: true });
-    }
-    catch {
-        // ignore
-    }
-    return { rolledBack: true };
-}
-/**
- * Called by post-boot health check once the hub is confirmed healthy after
- * a framework swap. Deletes all backups and the confirm marker so the old
- * framework packages are cleaned up.
- */
-function confirmFrameworkSwapHealthy(dataDir) {
-    const confirmPath = path.join(dataDir, SWAP_CONFIRM_MARKER);
-    if (!fs.existsSync(confirmPath))
-        return;
-    const raw = readJsonSafe(confirmPath);
-    if (!isSwapConfirmMarker(raw)) {
-        // corrupt marker — still delete it
-        try {
-            fs.rmSync(confirmPath, { force: true });
-        }
-        catch {
-            // ignore
-        }
-        return;
-    }
-    const confirm = raw;
-    // Delete all backup dirs
-    for (const backup of confirm.backups) {
-        try {
-            fs.rmSync(backup.backupPath, { recursive: true, force: true });
-        }
-        catch {
-            // best-effort cleanup
-        }
-    }
-    // Delete the confirm marker
-    try {
-        fs.rmSync(confirmPath, { force: true });
-    }
-    catch {
-        // ignore
-    }
-}

package/dist/request-framework-swap.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.requestFrameworkSwapAndRestart = requestFrameworkSwapAndRestart;
-/**
- * The single seam that joins the two halves of a framework-swap request:
- *   1. write the durable `.pending-framework-swap.json` marker (consumed by the
- *      zero-dep launcher on the NEXT boot), and
- *   2. schedule the self-restart that makes the launcher actually run.
- *
- * The launcher (`launcher-framework-swap.ts`) runs before `@camstack/system`
- * is imported and is deliberately zero-dep, so it cannot own the restart — that
- * lives in `@camstack/system`. This module is the ONLY owner of "stage a
- * framework swap → reboot": every engine path that stages the framework (single
- * `updateFrameworkPackage`, the "Update all" bulk job, and the auto-update
- * scheduler) wires its `requestFrameworkSwap` dep to this helper and gets the
- * reboot for free. The lifecycle engine assumes the process exits after
- * `requestFrameworkSwap` returns; without the restart here the marker is written
- * but never applied, silently stranding the update on disk.
- */
-const system_1 = require("@camstack/system");
-const launcher_framework_swap_js_1 = require("./launcher-framework-swap.js");
-/** Delay before the hub exits — lets the in-flight startJob reply drain first. */
-const FRAMEWORK_SWAP_RESTART_DELAY_MS = 500;
-/**
- * Write the pending-swap marker, then schedule the self-restart. The restart is
- * UNCONDITIONAL: a staged framework swap is inert until the launcher applies it
- * on reboot, so staging without restarting would silently lose the update.
- */
-function requestFrameworkSwapAndRestart(dataDir, input, deps = {}) {
-    const writeMarker = deps.writeMarker ?? launcher_framework_swap_js_1.writePendingFrameworkSwap;
-    const scheduleRestart = deps.scheduleRestart ?? system_1.scheduleSelfRestart;
-    const now = deps.now ?? Date.now;
-    writeMarker(dataDir, {
-        jobId: input.jobId,
-        taskId: input.taskId,
-        packages: input.packages,
-        requestedAtMs: now(),
-        schemaVersion: 1,
-    });
-    scheduleRestart({ delayMs: FRAMEWORK_SWAP_RESTART_DELAY_MS });
-}

package/dist/server-root/boot-plan.js

@@ -1,110 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.planBoot = planBoot;
-/**
- * Decide the boot target. Never throws; never mutates `state`.
- * `stateToWrite` is non-null whenever the durable state must change
- * (probation counter bump, rollback, invalid-version eviction).
- */
-function planBoot(state, isValidVersion, now) {
-    if (state === null) {
-        return { kind: 'baked', reason: 'no server-root state', stateToWrite: null };
-    }
-    let next = state;
-    let changed = false;
-    // ── Pending (freshly-staged) version ──────────────────────────────────
-    if (next.pendingBoot !== null) {
-        const pending = next.pendingBoot;
-        if (pending.bootAttempts >= 1) {
-            // Previous probation boot never confirmed healthy — roll back.
-            next = {
-                ...next,
-                pendingBoot: null,
-                rolledBack: {
-                    fromVersion: pending.version,
-                    toVersion: next.currentVersion,
-                    atMs: now(),
-                    reason: 'probation boot did not reach ready — rolled back',
-                },
-            };
-            changed = true;
-        }
-        else if (!isValidVersion(pending.version)) {
-            next = {
-                ...next,
-                pendingBoot: null,
-                rolledBack: {
-                    fromVersion: pending.version,
-                    toVersion: next.currentVersion,
-                    atMs: now(),
-                    reason: 'staged version failed validation',
-                },
-            };
-            changed = true;
-        }
-        else {
-            // Probation boot: bump the attempt counter durably, keep currentVersion
-            // untouched until the hub confirms the boot healthy.
-            return {
-                kind: 'data-root',
-                version: pending.version,
-                probation: true,
-                stateToWrite: {
-                    ...next,
-                    pendingBoot: { ...pending, bootAttempts: pending.bootAttempts + 1 },
-                },
-            };
-        }
-    }
-    // ── Confirmed current version ──────────────────────────────────────────
-    if (next.currentVersion !== null) {
-        if (isValidVersion(next.currentVersion)) {
-            return {
-                kind: 'data-root',
-                version: next.currentVersion,
-                probation: false,
-                stateToWrite: changed ? next : null,
-            };
-        }
-        // Current version dir is broken — try N-1, else baked.
-        const broken = next.currentVersion;
-        if (next.previousVersion !== null && isValidVersion(next.previousVersion)) {
-            const fallback = next.previousVersion;
-            return {
-                kind: 'data-root',
-                version: fallback,
-                probation: false,
-                stateToWrite: {
-                    ...next,
-                    currentVersion: fallback,
-                    previousVersion: null,
-                    rolledBack: {
-                        fromVersion: broken,
-                        toVersion: fallback,
-                        atMs: now(),
-                        reason: 'active version failed validation',
-                    },
-                },
-            };
-        }
-        return {
-            kind: 'baked',
-            reason: `active version ${broken} failed validation and no valid previous version exists`,
-            stateToWrite: {
-                ...next,
-                currentVersion: null,
-                rolledBack: {
-                    fromVersion: broken,
-                    toVersion: null,
-                    atMs: now(),
-                    reason: 'active version failed validation',
-                },
-            },
-        };
-    }
-    return {
-        kind: 'baked',
-        reason: 'no active data-root version',
-        stateToWrite: changed ? next : null,
-    };
-}

package/dist/server-root/semver-compare.js

@@ -1,45 +0,0 @@
-"use strict";
-/**
- * Minimal semver comparison — zero-dep (used by the starter, which must never
- * import from node_modules). Handles `MAJOR.MINOR.PATCH[-prerelease]`:
- * numeric segment compare, missing segments = 0, prerelease < its release,
- * prereleases of the same base compare lexically. Malformed segments compare
- * as 0 (best effort — never throws).
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compareSemver = compareSemver;
-function parse(version) {
-    const dashIdx = version.indexOf('-');
-    const base = dashIdx === -1 ? version : version.slice(0, dashIdx);
-    const prerelease = dashIdx === -1 ? null : version.slice(dashIdx + 1);
-    const nums = base.split('.').map((seg) => {
-        const n = Number.parseInt(seg, 10);
-        return Number.isNaN(n) ? 0 : n;
-    });
-    return { nums, prerelease };
-}
-/** Returns -1 when a < b, 0 when equal, 1 when a > b. */
-function compareSemver(a, b) {
-    const pa = parse(a);
-    const pb = parse(b);
-    const len = Math.max(pa.nums.length, pb.nums.length);
-    for (let i = 0; i < len; i++) {
-        const na = pa.nums[i] ?? 0;
-        const nb = pb.nums[i] ?? 0;
-        if (na < nb)
-            return -1;
-        if (na > nb)
-            return 1;
-    }
-    if (pa.prerelease === null && pb.prerelease === null)
-        return 0;
-    if (pa.prerelease === null)
-        return 1;
-    if (pb.prerelease === null)
-        return -1;
-    if (pa.prerelease < pb.prerelease)
-        return -1;
-    if (pa.prerelease > pb.prerelease)
-        return 1;
-    return 0;
-}