@camstack/server 1.0.4 → 1.0.6

package/dist/api/core/cap-providers.js

@@ -75,8 +75,8 @@ const types_1 = require("@camstack/types");
 const system_1 = require("@camstack/system");
 const integration_id_backfill_1 = require("../../boot/integration-id-backfill");
 const collection_preference_js_1 = require("./collection-preference.js");
-const bulk_update_coordinator_js_1 = require("./bulk-update-coordinator.js");
 const addon_package_service_js_1 = require("../../core/addon/addon-package.service.js");
+const lifecycle_runner_singleton_js_1 = require("../../core/lifecycle/lifecycle-runner.singleton.js");
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 // ── system ──────────────────────────────────────────────────────────
 function getRetention(registry) {
@@ -907,42 +907,14 @@ async function fetchAgentInstalledPackages(broker, nodeId) {
     }
     return out;
 }
-function buildAddonsProvider(ar, ps, ls, moleculer, configService, ctx, eb) {
+function buildAddonsProvider(ar, ps, ls, moleculer, configService, ctx) {
     const broker = moleculer.broker;
-    // Adapt the hub EventBusService (which takes a full SystemEvent object) to
-    // the IBulkUpdateEventBus interface (which takes (category, payload) pairs).
-    // Using `import { EventCategory }` from @camstack/types avoids a new import
-    // — it is already resolved in the generated-cap-routers layer above. The
-    // `eb.emit` overload that takes a TypedSystemEvent is the type-safe path.
-    const bulkEventBus = {
-        emit: (category, payload) => {
-            eb.emit({
-                id: (0, node_crypto_1.randomUUID)(),
-                timestamp: new Date(),
-                source: { type: 'core', id: 'bulk-update-coordinator' },
-                category,
-                data: payload,
-            });
-        },
-    };
-    const bulkCoordinator = new bulk_update_coordinator_js_1.BulkUpdateCoordinator({
-        eventBus: bulkEventBus,
-        updateAddon: async (i) => {
-            await ps.updatePackage(i.name, i.version);
-        },
-        updateFrameworkPackage: async (i) => {
-            await ps.updateFrameworkPackage({
-                packageName: i.packageName,
-                version: i.version,
-                deferRestart: i.deferRestart,
-            });
-        },
-        restartServer: async () => {
-            await ps.restartServer(ctx.user?.username ?? ctx.user?.id);
-        },
-        logger: ls.createLogger('bulk-update'),
-    });
     const frameworkAllowSet = new Set([addon_package_service_js_1.SYSTEM_PACKAGE]);
+    // Process-wide runner built once at boot (manual-boot wires its deps from the
+    // addon-package service + event bus). `createdBy` travels per `startJob` call.
+    const lifecycleRunner = (0, lifecycle_runner_singleton_js_1.getLifecycleRunner)();
+    // Who triggered each lifecycle job from this request context.
+    const lifecycleCreatedBy = ctx.user?.username ?? ctx.user?.id ?? 'system';
     return {
         list: async () => {
             const rollbackable = ps.getRollbackablePackages();
@@ -986,13 +958,30 @@ function buildAddonsProvider(ar, ps, ls, moleculer, configService, ctx, eb) {
         updatePackage: async (input) => {
             const nodeId = input.nodeId;
             if (nodeId === undefined || isHubNode(nodeId)) {
-                return ps.updatePackage(input.name, input.version);
+                // Hub-single: route through the lifecycle job engine so the fast
+                // staged-swap path (applyStagedAddonUpdate) is always used.
+                const version = input.version ?? 'latest';
+                const { jobId } = await lifecycleRunner.startJob({
+                    kind: 'update',
+                    targets: [{ name: input.name, version }],
+                    createdBy: lifecycleCreatedBy,
+                });
+                const job = lifecycleRunner.getJob(jobId);
+                const task = job?.tasks[0];
+                if (task?.phase === 'done') {
+                    return { success: true, name: input.name, version, jobId };
+                }
+                return { success: false, error: task?.error ?? 'update failed', jobId };
             }
             // Agent target: the hub packs the resolved version and ships the
             // tarball over `$agent.deploy` — the agent has no npm runtime.
+            // The reload re-instantiates the changed package's addons; for a large
+            // package (e.g. the whole pipeline stack) that can take well over a
+            // minute, so allow generous headroom — a timeout here aborts the call
+            // even though the deploy already landed on disk.
             const packed = await ps.packPackage(input.name, input.version);
-            await broker.call('$agent.deploy', { addonId: input.name, bundle: packed.buffer }, { nodeID: nodeId, timeout: 120_000 });
-            await broker.call('$agent.reload', {}, { nodeID: nodeId, timeout: 120_000 });
+            await broker.call('$agent.deploy', { addonId: input.name, bundle: packed.buffer }, { nodeID: nodeId, timeout: 300_000 });
+            await broker.call('$agent.reload', {}, { nodeID: nodeId, timeout: 300_000 });
             return { success: true, name: input.name, version: packed.version, nodeId };
         },
         rollbackPackage: async (input) => ps.rollbackPackage(input.name),
@@ -1071,6 +1060,7 @@ function buildAddonsProvider(ar, ps, ls, moleculer, configService, ctx, eb) {
                     ? { requestedBy: ctx.user.id }
                     : {}),
             ...(input.deferRestart !== undefined ? { deferRestart: input.deferRestart } : {}),
+            runner: lifecycleRunner,
         }),
         getVersions: async (input) => ps.getPackageVersions(input.name),
         restartAddon: async (input) => ar.restartAddon(input.addonId),
@@ -1089,10 +1079,16 @@ function buildAddonsProvider(ar, ps, ls, moleculer, configService, ctx, eb) {
             }
             return { success: true };
         },
-        startBulkUpdate: async (input) => bulkCoordinator.start(input),
-        getBulkUpdateState: async ({ id }) => bulkCoordinator.get(id),
-        cancelBulkUpdate: async ({ id }) => bulkCoordinator.cancel(id),
-        listActiveBulkUpdates: async ({ nodeId }) => bulkCoordinator.list(nodeId),
+        // ── Lifecycle job engine ─────────────────────────────────────────
+        startJob: async (input) => lifecycleRunner.startJob({
+            kind: input.kind,
+            targets: input.targets,
+            nodeIds: input.nodeIds,
+            createdBy: lifecycleCreatedBy,
+        }),
+        getJob: async (input) => lifecycleRunner.getJob(input.jobId),
+        listJobs: async (input) => lifecycleRunner.listJobs({ activeOnly: input.activeOnly }),
+        cancelJob: async (input) => lifecycleRunner.cancelJob(input.jobId),
         custom: async (input) => {
             const registry = ar.getCustomActionRegistry();
             const entry = registry.resolve(input.addonId, input.action);

package/dist/api/core/lifecycle-job-runner.js

@@ -0,0 +1,157 @@
+"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.createLifecycleJobRunner = createLifecycleJobRunner;
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const system_1 = require("@camstack/system");
+const addon_package_service_js_1 = require("../../core/addon/addon-package.service.js");
+const lifecycle_journal_path_js_1 = require("../../lifecycle-journal-path.js");
+/**
+ * Resolve a target's `TaskTarget` discriminant.
+ * Explicit `target` field wins; otherwise auto-detected from package name.
+ */
+function resolveTaskTarget(t) {
+    if (t.target !== undefined)
+        return t.target;
+    return t.name === addon_package_service_js_1.SYSTEM_PACKAGE ? 'framework' : 'addon';
+}
+/**
+ * Factory that wires `JobJournal` + `StagingArea` + `LifecycleJobEngine`
+ * into a thin façade that cap-providers delegates to.
+ *
+ * Each server boot creates a fresh instance (journals persist on disk; the
+ * in-memory running-set does not).
+ */
+function createLifecycleJobRunner(deps) {
+    const nowFn = deps.now ?? (() => Date.now());
+    const journalDir = (0, lifecycle_journal_path_js_1.lifecycleJobsDir)(deps.dataDir);
+    const stagingDir = path.join(deps.dataDir, 'lifecycle', 'staging');
+    const journal = new system_1.JobJournal(journalDir);
+    const staging = new system_1.StagingArea(stagingDir, {
+        fetchTarball: deps.fetchTarball,
+        extract: deps.extract,
+    });
+    const engine = new system_1.LifecycleJobEngine({
+        journal,
+        staging,
+        applyAddonUpdate: deps.applyAddonUpdate,
+        emit: deps.emit,
+        now: nowFn,
+        stageFramework: deps.stageFramework,
+        requestFrameworkSwap: deps.requestFrameworkSwap,
+    });
+    /**
+     * Set of jobIds currently executing — used to guard cancellation.
+     * We only block cancellation of running jobs (cannot abort mid-flight).
+     */
+    const runningJobs = new Set();
+    return {
+        async startJob(input) {
+            const jobId = (0, node_crypto_1.randomUUID)();
+            const job = {
+                jobId,
+                kind: input.kind,
+                createdAtMs: nowFn(),
+                createdBy: input.createdBy,
+                scope: input.targets.length === 1 ? 'single' : 'bulk',
+                schemaVersion: 1,
+                state: 'running',
+                tasks: input.targets.map((t) => ({
+                    taskId: (0, node_crypto_1.randomUUID)(),
+                    nodeId: 'hub',
+                    packageName: t.name,
+                    fromVersion: null,
+                    toVersion: t.version,
+                    target: resolveTaskTarget(t),
+                    phase: 'queued',
+                    stagedPath: null,
+                    attempts: 0,
+                    steps: [],
+                    error: null,
+                    startedAtMs: null,
+                    finishedAtMs: null,
+                })),
+            };
+            journal.createJob(job);
+            runningJobs.add(jobId);
+            try {
+                await engine.runJob(job);
+            }
+            finally {
+                runningJobs.delete(jobId);
+            }
+            return { jobId };
+        },
+        getJob(jobId) {
+            return journal.getJob(jobId);
+        },
+        listJobs(opts) {
+            return journal.listJobs(opts);
+        },
+        cancelJob(jobId) {
+            if (runningJobs.has(jobId)) {
+                // Cannot cancel a job that is actively running.
+                return { cancelled: false };
+            }
+            const job = journal.getJob(jobId);
+            if (!job || job.state !== 'running') {
+                return { cancelled: false };
+            }
+            journal.setJobState(jobId, 'cancelled');
+            return { cancelled: true };
+        },
+        async reconcile() {
+            // §10 boot reconcile: re-drive every active (non-terminal) job from its
+            // on-disk checkpoint. `resumed` = jobs that progressed without ending in a
+            // `failed` final state (a job left `running` because a framework task is
+            // still pending its reboot resume counts as resumed — it made progress and
+            // did not fail). `failed` = jobs whose final state is `failed`.
+            const jobs = journal.listJobs({ activeOnly: true });
+            let resumed = 0;
+            let failed = 0;
+            for (const job of jobs) {
+                const result = await engine.reconcileJob(job);
+                if (result.state === 'failed') {
+                    failed += 1;
+                }
+                else {
+                    resumed += 1;
+                }
+            }
+            return { resumed, failed };
+        },
+    };
+}

package/dist/api/trpc/generated-cap-routers.js

@@ -595,38 +595,6 @@ function createCapRouter_addons(getProvider, _createRemoteProxy) {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
             return p.updateFrameworkPackage(input);
         }),
-        startBulkUpdate: trpc_middleware_js_1.adminProcedure
-            .input(types_10.addonsCapability.methods.startBulkUpdate.input.loose())
-            .output(types_10.addonsCapability.methods.startBulkUpdate.output)
-            .mutation(async ({ input, ctx }) => {
-            const p = requireCapProvider('addons', () => getProvider(ctx));
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
-            return p.startBulkUpdate(input);
-        }),
-        getBulkUpdateState: trpc_middleware_js_1.adminProcedure
-            .input(types_10.addonsCapability.methods.getBulkUpdateState.input.loose())
-            .output(types_10.addonsCapability.methods.getBulkUpdateState.output)
-            .query(async ({ input, ctx }) => {
-            const p = requireCapProvider('addons', () => getProvider(ctx));
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
-            return p.getBulkUpdateState(input);
-        }),
-        cancelBulkUpdate: trpc_middleware_js_1.adminProcedure
-            .input(types_10.addonsCapability.methods.cancelBulkUpdate.input.loose())
-            .output(types_10.addonsCapability.methods.cancelBulkUpdate.output)
-            .mutation(async ({ input, ctx }) => {
-            const p = requireCapProvider('addons', () => getProvider(ctx));
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
-            return p.cancelBulkUpdate(input);
-        }),
-        listActiveBulkUpdates: trpc_middleware_js_1.adminProcedure
-            .input(types_10.addonsCapability.methods.listActiveBulkUpdates.input.loose())
-            .output(types_10.addonsCapability.methods.listActiveBulkUpdates.output)
-            .query(async ({ input, ctx }) => {
-            const p = requireCapProvider('addons', () => getProvider(ctx));
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
-            return p.listActiveBulkUpdates(input);
-        }),
         getVersions: trpc_middleware_js_1.protectedProcedure
             .input(types_10.addonsCapability.methods.getVersions.input.loose())
             .output(types_10.addonsCapability.methods.getVersions.output)
@@ -699,6 +667,38 @@ function createCapRouter_addons(getProvider, _createRemoteProxy) {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
             return p.custom(input);
         }),
+        startJob: trpc_middleware_js_1.adminProcedure
+            .input(types_10.addonsCapability.methods.startJob.input.loose())
+            .output(types_10.addonsCapability.methods.startJob.output)
+            .mutation(async ({ input, ctx }) => {
+            const p = requireCapProvider('addons', () => getProvider(ctx));
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.startJob(input);
+        }),
+        getJob: trpc_middleware_js_1.adminProcedure
+            .input(types_10.addonsCapability.methods.getJob.input.loose())
+            .output(types_10.addonsCapability.methods.getJob.output)
+            .query(async ({ input, ctx }) => {
+            const p = requireCapProvider('addons', () => getProvider(ctx));
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.getJob(input);
+        }),
+        listJobs: trpc_middleware_js_1.adminProcedure
+            .input(types_10.addonsCapability.methods.listJobs.input.loose())
+            .output(types_10.addonsCapability.methods.listJobs.output)
+            .query(async ({ input, ctx }) => {
+            const p = requireCapProvider('addons', () => getProvider(ctx));
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.listJobs(input);
+        }),
+        cancelJob: trpc_middleware_js_1.adminProcedure
+            .input(types_10.addonsCapability.methods.cancelJob.input.loose())
+            .output(types_10.addonsCapability.methods.cancelJob.output)
+            .mutation(async ({ input, ctx }) => {
+            const p = requireCapProvider('addons', () => getProvider(ctx));
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.cancelJob(input);
+        }),
         onAddonLogs: trpc_middleware_js_1.protectedProcedure
             .input(types_10.addonsCapability.methods.onAddonLogs.input)
             .subscription(({ input, ctx }) => {

package/dist/api/trpc/trpc.router.js

@@ -116,7 +116,7 @@ function buildCapabilityRouters(services) {
         toast: (0, generated_cap_routers_1.createCapRouter_toast)((ctx) => (0, cap_providers_js_1.buildToastProvider)(services.toastService, ctx)),
         integrations: (0, generated_cap_routers_1.createCapRouter_integrations)((_ctx) => (0, cap_providers_js_1.buildIntegrationsProvider)(services.addonRegistry, services.eventBus, services.loggingService, services.capabilityRegistry)),
         nodes: (0, generated_cap_routers_1.createCapRouter_nodes)((_ctx) => (0, cap_providers_js_1.buildNodesProvider)(services.agentRegistry, services.moleculer, services.addonRegistry)),
-        addons: (0, generated_cap_routers_1.createCapRouter_addons)((ctx) => (0, cap_providers_js_1.buildAddonsProvider)(services.addonRegistry, services.addonPackageService, services.loggingService, services.moleculer, services.configService, ctx, services.eventBus)),
+        addons: (0, generated_cap_routers_1.createCapRouter_addons)((ctx) => (0, cap_providers_js_1.buildAddonsProvider)(services.addonRegistry, services.addonPackageService, services.loggingService, services.moleculer, services.configService, ctx)),
         // ── Cap overrides: cross-node remote-proxy cast ─────────────────
         // These caps' providers have manual interface types that pre-date
         // `InferProvider<typeof xCap>` — structurally identical, nominally

package/dist/boot/post-boot.service.js

@@ -4,6 +4,8 @@ exports.PostBootService = void 0;
 const node_crypto_1 = require("node:crypto");
 const system_1 = require("@camstack/system");
 const types_1 = require("@camstack/types");
+const resume_framework_swap_js_1 = require("./resume-framework-swap.js");
+const reconcile_lifecycle_jobs_js_1 = require("./reconcile-lifecycle-jobs.js");
 class PostBootService {
     eventBus;
     logger;
@@ -55,6 +57,29 @@ class PostBootService {
         // restart, …). `readPendingRestart` clears the marker atomically so
         // we never re-fire on a crash-loop boot.
         this.emitRestartCompletedIfPending(dataPath);
+        // If a framework swap was applied on the previous boot and left a
+        // `.framework-swap-confirm.json` marker, mark the journal job done and
+        // delete the marker + backups now that the hub is healthy.  This also
+        // disarms the crash-loop rollback (the NEXT boot won't roll back a
+        // healthy update).
+        await this.resumeFrameworkSwapIfPending(dataPath);
+        // Then re-drive every other non-terminal lifecycle job (addon task phases)
+        // from its on-disk checkpoint. Order matters: framework resume FIRST (marks
+        // the framework task `applied`→`done`), THEN addon reconcile (which leaves
+        // framework tasks untouched).
+        await this.reconcileLifecycleJobsIfAny();
+    }
+    async resumeFrameworkSwapIfPending(dataDir) {
+        const result = await (0, resume_framework_swap_js_1.resumeFrameworkSwapJob)(dataDir);
+        if (result.resumed) {
+            this.logger.info('Framework update completed', { meta: { jobId: result.jobId } });
+        }
+    }
+    async reconcileLifecycleJobsIfAny() {
+        const { resumed, failed } = await (0, reconcile_lifecycle_jobs_js_1.reconcileLifecycleJobsAtBoot)();
+        if (resumed + failed > 0) {
+            this.logger.info('Lifecycle jobs reconciled at boot', { meta: { resumed, failed } });
+        }
     }
     emitRestartCompletedIfPending(dataDir) {
         const marker = (0, system_1.readPendingRestart)(dataDir);

package/dist/boot/reconcile-lifecycle-jobs.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * Boot-time §10 reconcile of all non-terminal lifecycle jobs.
+ *
+ * After a crash mid-job (an "Update all" bulk job, a single addon update, …)
+ * the on-disk journal holds tasks parked in a non-terminal phase. This boot
+ * entry re-drives every active job through the engine so each addon task
+ * resumes from its checkpoint (reusing a still-valid `stagedPath` or
+ * re-fetching, then applying).
+ *
+ * Best-effort, mirrors `resume-framework-swap.ts`: this NEVER throws — any error
+ * (runner not initialized, journal corruption, …) is swallowed and reported as
+ * `{ resumed: 0, failed: 0 }` so the post-boot path can never crash the hub.
+ *
+ * Ordering note: the framework `applied`→`done` resume (`resumeFrameworkSwapJob`)
+ * MUST run BEFORE this — reconcile deliberately leaves framework tasks untouched.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reconcileLifecycleJobsAtBoot = reconcileLifecycleJobsAtBoot;
+const lifecycle_runner_singleton_js_1 = require("../core/lifecycle/lifecycle-runner.singleton.js");
+async function reconcileLifecycleJobsAtBoot() {
+    try {
+        return await (0, lifecycle_runner_singleton_js_1.getLifecycleRunner)().reconcile();
+    }
+    catch {
+        // Never crash the post-boot path.
+        return { resumed: 0, failed: 0 };
+    }
+}

package/dist/boot/resume-framework-swap.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * Boot-time framework-swap job resume + health confirm.
+ *
+ * After a framework swap reboot, `post-boot.service.ts` calls this once the
+ * hub is healthy.  It:
+ *   1. Reads `.framework-swap-confirm.json` (written by the launcher on apply).
+ *   2. Marks the journal task `applied` → `done`, then finalises the job →
+ *      `completed`.
+ *   3. Calls `confirmFrameworkSwapHealthy` to delete the confirm marker +
+ *      backup dirs (disarms the crash-loop rollback).
+ *
+ * Best-effort: a missing/corrupt journal is tolerated — `confirmFrameworkSwapHealthy`
+ * is still called so the rollback is always disarmed when the hub boots healthy.
+ */
+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.resumeFrameworkSwapJob = resumeFrameworkSwapJob;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const types_1 = require("@camstack/types");
+const system_1 = require("@camstack/system");
+const launcher_framework_swap_js_1 = require("../launcher-framework-swap.js");
+const lifecycle_journal_path_js_1 = require("../lifecycle-journal-path.js");
+const SWAP_CONFIRM_FILE = '.framework-swap-confirm.json';
+/**
+ * Resume a framework-swap journal job to `done`/`completed` and confirm the
+ * hub is healthy (deletes the confirm marker + backups).
+ *
+ * @returns `{ resumed: false }` when no confirm marker exists.
+ *          `{ resumed: true, jobId }` when the marker was found and processed.
+ *          Never throws — errors are swallowed to avoid crashing the post-boot path.
+ */
+async function resumeFrameworkSwapJob(dataDir) {
+    try {
+        const confirmMarker = readConfirmMarker(dataDir);
+        if (confirmMarker === null) {
+            return { resumed: false };
+        }
+        const { jobId, taskId } = confirmMarker;
+        let journalPatched = false;
+        try {
+            const journal = new system_1.JobJournal((0, lifecycle_journal_path_js_1.lifecycleJobsDir)(dataDir));
+            const job = journal.getJob(jobId);
+            if (job !== null) {
+                const task = job.tasks.find((t) => t.taskId === taskId);
+                if (task !== undefined && task.phase === 'applied') {
+                    journal.patchTask(jobId, taskId, { phase: 'done', finishedAtMs: Date.now() });
+                    // Single-task framework job: if all tasks are now terminal and none
+                    // failed, mark the job completed (mirrors the engine's finalize logic).
+                    const updatedJob = journal.getJob(jobId);
+                    if (updatedJob !== null) {
+                        const allTerminal = updatedJob.tasks.every((t) => t.phase === 'done' || t.phase === 'failed' || t.phase === 'skipped');
+                        const anyFailed = updatedJob.tasks.some((t) => t.phase === 'failed');
+                        if (allTerminal && !anyFailed) {
+                            journal.setJobState(jobId, 'completed');
+                        }
+                    }
+                    journalPatched = true;
+                }
+            }
+        }
+        catch {
+            // Journal is missing or corrupt — still clean up the confirm marker so
+            // the rollback is disarmed on a healthy hub boot.
+        }
+        (0, launcher_framework_swap_js_1.confirmFrameworkSwapHealthy)(dataDir);
+        return journalPatched ? { resumed: true, jobId } : { resumed: false };
+    }
+    catch {
+        // Never crash the caller (post-boot service).
+        return { resumed: false };
+    }
+}
+/** Read and shape-check the confirm marker.  Returns null on any error. */
+function readConfirmMarker(dataDir) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(path.join(dataDir, SWAP_CONFIRM_FILE), 'utf-8'));
+        const parsed = types_1.frameworkSwapConfirmSchema.safeParse(raw);
+        if (!parsed.success)
+            return null;
+        return { jobId: parsed.data.jobId, taskId: parsed.data.taskId };
+    }
+    catch {
+        return null;
+    }
+}