@camstack/server 1.0.5 → 1.0.6

package/dist/manual-boot.js

@@ -6,12 +6,51 @@
  * removed to drop the accidental DI layer on top of an already-explicit
  * dependency graph.
  */
+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;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bootManual = bootManual;
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
 const fastify_1 = __importDefault(require("fastify"));
+const system_1 = require("@camstack/system");
+const types_1 = require("@camstack/types");
+const lifecycle_runner_singleton_1 = require("./core/lifecycle/lifecycle-runner.singleton");
+const request_framework_swap_1 = require("./request-framework-swap");
 const config_service_1 = require("./core/config/config.service");
 const logging_service_1 = require("./core/logging/logging.service");
 const event_bus_service_1 = require("./core/events/event-bus.service");
@@ -94,6 +133,60 @@ async function bootManual(opts) {
     // dist sub-folder lookup (see service docstring).
     const addonWidgetsService = new addon_widgets_service_1.AddonWidgetsService(loggingService, capabilityService, addonRegistryService);
     const addonPackageService = new addon_package_service_1.AddonPackageService(loggingService, eventBusService, configService, addonRegistryService, notificationWrapper, toastWrapper);
+    // ---- Lifecycle job runner (boot singleton) -----------------------------
+    // The runner used to be built per-tRPC-request inside the `addons` cap
+    // factory. Boot-reconcile (F3 Task 4) and the auto-update scheduler (F3
+    // Task 5) need a stable instance that exists before any request, so we build
+    // it ONCE here from the addon-package service + event bus. `createdBy` is no
+    // longer a construction dep — it travels on each `startJob` call.
+    const lifecycleDataDir = path.resolve(process.env['CAMSTACK_DATA'] ?? 'camstack-data');
+    (0, lifecycle_runner_singleton_1.initLifecycleRunner)({
+        dataDir: lifecycleDataDir,
+        fetchTarball: (name, version, signal) => addonPackageService.fetchAddonTarball(name, version, signal),
+        extract: (tgz, destDir) => addonPackageService.extractTarball(tgz, destDir),
+        applyAddonUpdate: async ({ name, version, stagedPath }) => {
+            await addonPackageService.applyStagedAddonUpdate(name, version, stagedPath);
+        },
+        emit: (kind, job, entry) => {
+            if (kind === 'progress') {
+                eventBusService.emit({
+                    id: (0, node_crypto_1.randomUUID)(),
+                    timestamp: new Date(),
+                    source: { type: 'core', id: 'lifecycle-job-engine' },
+                    category: types_1.EventCategory.AddonsJobProgress,
+                    data: { job },
+                });
+            }
+            else {
+                eventBusService.emit({
+                    id: (0, node_crypto_1.randomUUID)(),
+                    timestamp: new Date(),
+                    source: { type: 'core', id: 'lifecycle-job-engine' },
+                    category: types_1.EventCategory.AddonsJobLog,
+                    data: { jobId: job.jobId, entry },
+                });
+            }
+        },
+        // ── Framework swap deps ──────────────────────────────────────────
+        stageFramework: (task, signal) => (0, system_1.stageFrameworkLockstep)({
+            jobId: task.taskId,
+            toVersion: task.toVersion,
+            frameworkDir: process.env['CAMSTACK_FRAMEWORK_DIR'] ?? '',
+            stagingDir: path.join(lifecycleDataDir, 'lifecycle', 'staging'),
+            fetchTarball: (name, version, sig) => addonPackageService.fetchAddonTarball(name, version, sig),
+            extract: (tgz, destDir) => addonPackageService.extractTarball(tgz, destDir),
+            resolveVersion: (name) => addonPackageService.resolveFrameworkVersion(name, task.toVersion),
+            currentVersionOf: (name) => addonPackageService.currentFrameworkVersionOf(name),
+            signal,
+        }),
+        requestFrameworkSwap: ({ jobId, taskId, packages }) => {
+            // Write the pending-swap marker AND schedule the reboot that applies it.
+            // The engine assumes the process exits after this returns; the restart is
+            // owned here (the single seam for every engine path: single update,
+            // "Update all" bulk, and the auto-update scheduler).
+            (0, request_framework_swap_1.requestFrameworkSwapAndRestart)(lifecycleDataDir, { jobId, taskId, packages });
+        },
+    });
     const replEngineService = new repl_engine_service_1.ReplEngineService(addonRegistryService, eventBusService, loggingService);
     const topologyEmitterService = new topology_emitter_service_1.TopologyEmitterService(eventBusService, agentRegistryService, addonRegistryService);
     const postBootService = new post_boot_service_1.PostBootService(addonRegistryService, eventBusService, loggingService);

package/dist/request-framework-swap.js

@@ -0,0 +1,41 @@
+"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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/server",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "private": false,
   "files": [
     "dist",

package/dist/api/core/bulk-update-coordinator.js

@@ -1,229 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BulkUpdateCoordinator = void 0;
-/* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-argument -- The server installs @camstack/types@0.1.38 (last published) in server/backend/node_modules, while the workspace has 0.1.39 with the new BulkUpdate* types. ESLint's type-checker resolves against 0.1.38 and treats the new imports as `any`. Runtime is correct because Node module resolution walks up to root node_modules → workspace symlink. This disable mirrors the pattern in cap-providers.ts (same root cause). Will resolve when 0.1.39 is published and the local dist is synced. */
-const node_crypto_1 = require("node:crypto");
-const types_1 = require("@camstack/types");
-const DEFAULT_CLEANUP_AFTER_MS = 5 * 60 * 1_000;
-class BulkUpdateCoordinator {
-    deps;
-    states = new Map();
-    cancelFlags = new Map();
-    /**
-     * Tracks wall-clock time (ms) when each bulk completed. Used for lazy
-     * cleanup in `get()` — avoids scheduling a fake-timer `setTimeout` that
-     * would be eagerly fired by `vi.runAllTimersAsync()` in tests.
-     */
-    completedWallMs = new Map();
-    /** Tracks which nodeIds currently have an active (non-completed) bulk update. */
-    activeNodeIds = new Set();
-    now;
-    cleanupAfterMs;
-    /** Wall-clock source. Fake timers intercept `Date.now`, so tests can advance via `advanceTimersByTimeAsync`. */
-    wallNow;
-    constructor(deps) {
-        this.deps = deps;
-        this.now = deps.clock ?? (() => Date.now());
-        this.cleanupAfterMs = deps.cleanupAfterMs ?? DEFAULT_CLEANUP_AFTER_MS;
-        this.wallNow = () => Date.now();
-    }
-    // ── Public API ────────────────────────────────────────────────────
-    start(input) {
-        if (this.activeNodeIds.has(input.nodeId)) {
-            throw new Error(`Bulk update already in progress for node ${input.nodeId}`);
-        }
-        const id = (0, node_crypto_1.randomUUID)();
-        const items = input.items.map((i) => ({
-            name: i.name,
-            isSystem: i.isSystem,
-            // fromVersion: the cap interface receives name+version+isSystem only;
-            // the caller (cap-providers.ts) may enrich this with the current version
-            // if available. Empty string is acceptable per plan spec.
-            fromVersion: '',
-            toVersion: i.version,
-            status: 'queued',
-        }));
-        const state = {
-            id,
-            nodeId: input.nodeId,
-            startedAtMs: this.now(),
-            total: items.length,
-            completed: 0,
-            failed: 0,
-            current: null,
-            phase: 'regular',
-            cancelled: false,
-            items,
-        };
-        this.states.set(id, state);
-        this.activeNodeIds.add(input.nodeId);
-        const cancelFlag = { cancelled: false };
-        this.cancelFlags.set(id, cancelFlag);
-        // Emit initial state so clients see the bulk as started immediately
-        this.emit(state);
-        void this.runLoop(id, cancelFlag).catch((err) => {
-            this.deps.logger.error('BulkUpdateCoordinator: loop crashed unexpectedly', err);
-        });
-        return { id };
-    }
-    get(id) {
-        const state = this.states.get(id);
-        if (state === undefined)
-            return null;
-        // Lazy cleanup: purge if the wall-clock elapsed since completion exceeds threshold.
-        // This avoids scheduling a long-lived setTimeout that would be eagerly fired
-        // by vi.runAllTimersAsync() in tests.
-        const completedWall = this.completedWallMs.get(id);
-        if (completedWall !== undefined && this.wallNow() - completedWall >= this.cleanupAfterMs) {
-            this.purge(id);
-            return null;
-        }
-        return state;
-    }
-    list(nodeId) {
-        const all = [...this.states.keys()]
-            .map((id) => this.get(id)) // get() applies lazy-cleanup
-            .filter((s) => s !== null);
-        return nodeId === undefined ? all : all.filter((s) => s.nodeId === nodeId);
-    }
-    cancel(id) {
-        const state = this.states.get(id);
-        const flag = this.cancelFlags.get(id);
-        if (state === undefined || flag === undefined)
-            return { cancelled: false };
-        // Once restarting, the hub restart is committed — cancel has no effect.
-        if (state.phase === 'restarting')
-            return { cancelled: false };
-        // Already completed.
-        if (state.completedAtMs !== undefined)
-            return { cancelled: false };
-        flag.cancelled = true;
-        this.mutate(id, (s) => ({ ...s, cancelled: true }));
-        return { cancelled: true };
-    }
-    // ── Internal loop ─────────────────────────────────────────────────
-    async runLoop(id, cancelFlag) {
-        const initial = this.states.get(id);
-        // ── Phase 1: regular addons ──────────────────────────────────────
-        this.transitionPhase(id, 'regular');
-        for (const item of initial.items.filter((i) => !i.isSystem)) {
-            if (cancelFlag.cancelled)
-                break;
-            await this.processItem(id, item, false);
-        }
-        // ── Phase 2: system packages (deferRestart: true) ────────────────
-        if (!cancelFlag.cancelled && initial.items.some((i) => i.isSystem)) {
-            this.transitionPhase(id, 'system');
-            for (const item of initial.items.filter((i) => i.isSystem)) {
-                if (cancelFlag.cancelled)
-                    break;
-                await this.processItem(id, item, true);
-            }
-            // ── Phase 3: single restart ──────────────────────────────────
-            const anySystemPendingRestart = this.states
-                .get(id)
-                .items.some((i) => i.isSystem && i.status === 'done-pending-restart');
-            if (anySystemPendingRestart && !cancelFlag.cancelled) {
-                this.transitionPhase(id, 'restarting');
-                try {
-                    await this.deps.restartServer({ confirm: true });
-                    // NOTE: In production, restartServer kills+respawns the hub process.
-                    // Code below this point will not execute in that scenario.
-                    // If the mock/stub returns (e.g. in tests), we fall through to finalizing.
-                }
-                catch (err) {
-                    // Restart failed but the npm installs already completed. Promote all
-                    // done-pending-restart items to done with a caveat error so the UI
-                    // can inform the user that a manual restart is needed.
-                    this.deps.logger.error('BulkUpdateCoordinator: restart failed', err);
-                    const errMsg = err instanceof Error ? err.message : String(err);
-                    for (const it of this.states.get(id).items) {
-                        if (it.status === 'done-pending-restart') {
-                            this.setItemStatus(id, it.name, 'done', {
-                                error: `Restart failed; manual restart required (${errMsg})`,
-                            });
-                        }
-                    }
-                }
-            }
-        }
-        // ── Phase 4: finalize ────────────────────────────────────────────
-        // Reached when:
-        //  a) no system packages at all, OR
-        //  b) restart failed (process continued), OR
-        //  c) cancelled before the restart phase.
-        this.transitionPhase(id, 'finalizing');
-        this.completeBulk(id);
-    }
-    async processItem(id, item, isSystem) {
-        this.setItemStatus(id, item.name, 'updating', { startedAtMs: this.now() });
-        this.mutate(id, (s) => ({ ...s, current: item.name }));
-        this.emit(this.states.get(id));
-        try {
-            if (isSystem) {
-                await this.deps.updateFrameworkPackage({
-                    packageName: item.name,
-                    version: item.toVersion,
-                    deferRestart: true,
-                });
-                this.setItemStatus(id, item.name, 'done-pending-restart', { completedAtMs: this.now() });
-            }
-            else {
-                await this.deps.updateAddon({ name: item.name, version: item.toVersion });
-                this.setItemStatus(id, item.name, 'done', { completedAtMs: this.now() });
-            }
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.setItemStatus(id, item.name, 'failed', { error: msg, completedAtMs: this.now() });
-        }
-        this.mutate(id, (s) => ({ ...s, current: null }));
-        this.emit(this.states.get(id));
-    }
-    // ── State mutation helpers ────────────────────────────────────────
-    setItemStatus(id, name, status, fields = {}) {
-        this.mutate(id, (s) => {
-            const items = s.items.map((it) => (it.name === name ? { ...it, status, ...fields } : it));
-            // completed = all terminal states: done | done-pending-restart | failed
-            const completed = items.filter((it) => it.status === 'done' || it.status === 'done-pending-restart' || it.status === 'failed').length;
-            const failed = items.filter((it) => it.status === 'failed').length;
-            return { ...s, items, completed, failed };
-        });
-    }
-    transitionPhase(id, phase) {
-        this.mutate(id, (s) => ({ ...s, phase }));
-        this.emit(this.states.get(id));
-    }
-    completeBulk(id) {
-        this.mutate(id, (s) => ({ ...s, completedAtMs: this.now(), current: null }));
-        this.emit(this.states.get(id));
-        // Free the nodeId slot so a new bulk for the same node can be started
-        const nodeId = this.states.get(id).nodeId;
-        this.activeNodeIds.delete(nodeId);
-        // Record wall-clock completion time for lazy cleanup in `get()`.
-        // We intentionally avoid scheduling a setTimeout here: a long-lived
-        // setTimeout (5 min) would be eagerly fired by vi.runAllTimersAsync()
-        // in tests, causing `get()` to return null immediately after the run.
-        // Instead, `get()` lazily checks whether the cleanup threshold has
-        // elapsed using Date.now() — which fake timers DO advance via
-        // advanceTimersByTimeAsync(), making the cleanup testable without
-        // a long-running timer.
-        this.completedWallMs.set(id, this.wallNow());
-    }
-    purge(id) {
-        this.states.delete(id);
-        this.cancelFlags.delete(id);
-        this.completedWallMs.delete(id);
-    }
-    /** Immutably update the state for the given id. No-op if id is unknown. */
-    mutate(id, update) {
-        const current = this.states.get(id);
-        if (current === undefined)
-            return;
-        this.states.set(id, update(current));
-    }
-    emit(state) {
-        this.deps.eventBus.emit(types_1.EventCategory.AddonsBulkUpdateProgress, state);
-    }
-}
-exports.BulkUpdateCoordinator = BulkUpdateCoordinator;