@camstack/system 1.2.2 → 1.2.4

package/dist/index.js

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("./chunk-Cek0wNdY.js");
-const require_dist = require("./dist-CkdNC8US.js");
+const require_dist = require("./dist-CQZxGJ8u.js");
 const require_model_download_service = require("./model-download-service-hf0ookyy.js");
-const require_manifest_python_deps = require("./manifest-python-deps-DRq5MreI.js");
+const require_manifest_python_deps = require("./manifest-python-deps-Cd7ocUBi.js");
 const require_resource_monitor = require("./resource-monitor-DNNomR-i.js");
 const require_builtins_sqlite_storage_filesystem_storage_addon = require("./builtins/sqlite-storage/filesystem-storage.addon.js");
 const require_builtins_sqlite_storage_sqlite_settings_addon = require("./builtins/sqlite-storage/sqlite-settings.addon.js");
@@ -184,7 +184,7 @@ function proxyToUpstream(opts) {
 }
 //#endregion
 //#region src/python/python-env-manager.ts
-var execFileAsync$3 = (0, node_util.promisify)(node_child_process.execFile);
+var execFileAsync$4 = (0, node_util.promisify)(node_child_process.execFile);
 var PythonEnvManager = class {
 	venvPath;
 	cachedProbe = null;
@@ -194,12 +194,12 @@ var PythonEnvManager = class {
 	async probe() {
 		if (this.cachedProbe) return this.cachedProbe;
 		for (const cmd of ["python3", "python"]) try {
-			const { stdout } = await execFileAsync$3(cmd, ["--version"]);
+			const { stdout } = await execFileAsync$4(cmd, ["--version"]);
 			const version = stdout.trim().replace("Python ", "");
 			const major = parseInt(version.split(".")[0] ?? "0", 10);
 			const minor = parseInt(version.split(".")[1] ?? "0", 10);
 			if (major < 3 || major === 3 && minor < 10) continue;
-			const { stdout: pathOut } = await execFileAsync$3(cmd, ["-c", "import sys; print(sys.executable)"]);
+			const { stdout: pathOut } = await execFileAsync$4(cmd, ["-c", "import sys; print(sys.executable)"]);
 			this.cachedProbe = {
 				available: true,
 				version,
@@ -215,13 +215,13 @@ var PythonEnvManager = class {
 	async ensure(options) {
 		const probe = await this.probe();
 		if (!probe.available || !probe.path) throw new Error("Python 3.10+ is required but not found on this system");
-		if (!node_fs.existsSync(node_path.join(this.venvPath, "bin", "python"))) await execFileAsync$3(probe.path, [
+		if (!node_fs.existsSync(node_path.join(this.venvPath, "bin", "python"))) await execFileAsync$4(probe.path, [
 			"-m",
 			"venv",
 			this.venvPath
 		]);
 		const venvPython = node_path.join(this.venvPath, "bin", "python");
-		if (options.packages.length > 0) await execFileAsync$3(venvPython, [
+		if (options.packages.length > 0) await execFileAsync$4(venvPython, [
 			"-m",
 			"pip",
 			"install",
@@ -1692,7 +1692,7 @@ function matchPath(pattern, path) {
 }
 //#endregion
 //#region src/tls/cert-manager.ts
-var execFileAsync$2 = (0, node_util.promisify)(node_child_process.execFile);
+var execFileAsync$3 = (0, node_util.promisify)(node_child_process.execFile);
 /**
 * Ensure a self-signed TLS certificate exists in the given directory.
 * Generates one if missing. Returns paths to cert and key files.
@@ -1729,7 +1729,7 @@ async function ensureTlsCert(dataDir, options) {
 	for (const dns of sanDns) sanParts.push(`DNS:${dns}`);
 	for (const ip of sanIps) sanParts.push(`IP:${ip}`);
 	const sanString = sanParts.join(",");
-	await execFileAsync$2("openssl", [
+	await execFileAsync$3("openssl", [
 		"req",
 		"-x509",
 		"-newkey",
@@ -2597,7 +2597,7 @@ var AddonEngineManager = class {
 };
 //#endregion
 //#region src/kernel/fs-utils.ts
-var execFileAsync$1 = (0, node_util.promisify)(node_child_process.execFile);
+var execFileAsync$2 = (0, node_util.promisify)(node_child_process.execFile);
 /**
 * Ensure a directory exists (recursive).
 * Single source of truth — replaces scattered mkdirSync calls.
@@ -2781,7 +2781,7 @@ function ensureLibraryBuilt(packageName, packagesDir) {
 async function installPackageFromNpm(packageName, targetDir) {
 	const tmpDir = await node_fs.promises.mkdtemp(node_path.join(node_os.tmpdir(), "camstack-install-"));
 	try {
-		const { stdout } = await execFileAsync$1("npm", [
+		const { stdout } = await execFileAsync$2("npm", [
 			"pack",
 			packageName,
 			"--pack-destination",
@@ -2795,7 +2795,7 @@ async function installPackageFromNpm(packageName, targetDir) {
 		const tgzPath = node_path.join(tmpDir, tgzFilename);
 		const extractDir = node_path.join(tmpDir, "extracted");
 		ensureDir(extractDir);
-		await execFileAsync$1("tar", [
+		await execFileAsync$2("tar", [
 			"-xzf",
 			tgzPath,
 			"-C",
@@ -3030,6 +3030,268 @@ var AddonManifest = class {
 	}
 };
 //#endregion
+//#region src/kernel/deps/ensure-native-prebuilds.ts
+/**
+* `ensureNativePrebuilds` — the post-install native-prebuild ENSURE step the
+* shared `RootUpdateService` runs while staging a `@camstack/server` closure,
+* BEFORE its `findMissingNativePrebuilds` validator (in `@camstack/node-root`)
+* decides whether to arm the swap.
+*
+* Why this exists (Mac desktop incident, 2026-07-21): a runtime
+* `applyServerUpdate` on a packaged desktop stages the closure with
+* `npm install @camstack/server@X` under the app's BUNDLED bare Node. The one
+* TRADITIONAL (non-N-API) native, `better-sqlite3`, resolves its `.node` via
+* its `install` script `prebuild-install || node-gyp rebuild`. On a user's Mac
+* with no build toolchain (and where the auto `prebuild-install` does not
+* target the bundled Node's ABI/arch the way the DMG build's EXPLICIT
+* `prebuild-install --runtime node --target <bundled> --arch <arch>` call does)
+* that leaves the module SOURCE-ONLY → the closure has no `better-sqlite3`
+* `.node` → the validator refuses the swap ("staged closure missing native
+* prebuilds: better-sqlite3"). The docker image never hits this: its Node ABI
+* has a published prebuild the auto path fetches cleanly, and it carries a
+* build toolchain fallback.
+*
+* This mirrors the DMG build's explicit re-fetch (`scripts/stage-deps.mjs`)
+* into the runtime staging path: for each traditional native that is present
+* in the closure but missing its compiled `.node`, fetch the prebuild for the
+* RUNNING Node ABI/arch (the same Node that will load the swapped closure).
+*
+* N-API natives (`sharp`, `node-av`) are ABI-stable and ship their binaries as
+* platform SIBLING packages that npm fetches reliably with no compile step, so
+* they are not in scope here — a genuine miss there is a broken install the
+* validator should still reject, not something a prebuild re-fetch can heal.
+*
+* Injected into the update service from the construction site so the zero-dep
+* `@camstack/node-root` layer never depends on npm/@camstack/system, and the
+* fetch is unit-testable with a fake fetcher.
+*/
+var execFileAsync$1 = (0, node_util.promisify)(node_child_process.execFile);
+/** Bounded recursive `.node` scan depth inside a module dir. */
+var NATIVE_SCAN_DEPTH = 4;
+/** Timeout for a single `prebuild-install` fetch. */
+var PREBUILD_FETCH_TIMEOUT_MS = 12e4;
+/**
+* Traditional (compile-or-prebuild) natives an installed closure must carry a
+* `.node` for. Only these are ENSURE-able by a prebuild re-fetch; N-API natives
+* are excluded (see file header).
+*/
+var TRADITIONAL_NATIVE_PACKAGES = ["better-sqlite3"];
+/** Bounded recursive scan for ANY `*.node` file under `dir`. */
+function hasDotNode(dir, maxDepth) {
+	let entries;
+	try {
+		entries = node_fs.readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return false;
+	}
+	for (const entry of entries) if (entry.isFile() && entry.name.endsWith(".node")) return true;
+	if (maxDepth <= 0) return false;
+	for (const entry of entries) if (entry.isDirectory() && hasDotNode(node_path.join(dir, entry.name), maxDepth - 1)) return true;
+	return false;
+}
+/** Locate the bundled `prebuild-install` bin.js inside the staged closure. */
+function resolvePrebuildInstallBin(closureDir, moduleDir) {
+	return [node_path.join(moduleDir, "node_modules", "prebuild-install", "bin.js"), node_path.join(closureDir, "node_modules", "prebuild-install", "bin.js")].find((c) => node_fs.existsSync(c)) ?? null;
+}
+/**
+* Default fetcher: run the closure's own `prebuild-install` under the CURRENT
+* Node (`process.execPath`) — no reliance on `npx`/`npm` on PATH (a packaged
+* app ships a bare Node). Explicitly targets the running ABI/arch, mirroring
+* `scripts/stage-deps.mjs`.
+*/
+function makeDefaultFetch(closureDir, logger) {
+	return async (moduleDir, target) => {
+		const bin = resolvePrebuildInstallBin(closureDir, moduleDir);
+		if (bin === null) throw new Error(`prebuild-install not found in the staged closure for ${moduleDir}`);
+		logger.info("fetching native prebuild via prebuild-install", { meta: {
+			moduleDir,
+			bin,
+			nodeVersion: target.nodeVersion,
+			arch: target.arch
+		} });
+		await execFileAsync$1(process.execPath, [
+			bin,
+			"--runtime",
+			"node",
+			"--target",
+			target.nodeVersion,
+			"--arch",
+			target.arch
+		], {
+			cwd: moduleDir,
+			timeout: PREBUILD_FETCH_TIMEOUT_MS
+		});
+	};
+}
+/**
+* Ensure every traditional native in `<closureDir>/node_modules` carries its
+* compiled `.node`, fetching the prebuild for the running ABI when missing.
+*
+* A NO-OP when nothing is missing (docker / tests) and when a native package is
+* absent from the closure. Never throws for a single package's fetch failure —
+* it logs and continues so the downstream `findMissingNativePrebuilds`
+* validator makes the final swap/abort decision. Returns the packages whose
+* prebuild was successfully fetched (for logging/tests).
+*/
+async function ensureNativePrebuilds(closureDir, options) {
+	const nm = node_path.join(closureDir, "node_modules");
+	const target = options.target ?? {
+		nodeVersion: process.versions.node,
+		arch: process.arch
+	};
+	const packages = options.packages ?? TRADITIONAL_NATIVE_PACKAGES;
+	const fetchPrebuild = options.fetchPrebuild ?? makeDefaultFetch(closureDir, options.logger);
+	const fetched = [];
+	for (const pkg of packages) {
+		const moduleDir = node_path.join(nm, pkg);
+		if (!node_fs.existsSync(moduleDir)) continue;
+		if (hasDotNode(moduleDir, 4)) continue;
+		options.logger.warn("staged closure native prebuild missing — fetching for running ABI", { meta: {
+			pkg,
+			moduleDir,
+			nodeVersion: target.nodeVersion,
+			arch: target.arch
+		} });
+		try {
+			await fetchPrebuild(moduleDir, target);
+		} catch (err) {
+			options.logger.error("native prebuild fetch failed (validator will decide)", { meta: {
+				pkg,
+				error: (0, _camstack_types_addon.errMsg)(err)
+			} });
+			continue;
+		}
+		if (hasDotNode(moduleDir, 4)) {
+			fetched.push(pkg);
+			options.logger.info("native prebuild fetched", { meta: { pkg } });
+		} else options.logger.error("native prebuild still missing after fetch", { meta: { pkg } });
+	}
+	return fetched;
+}
+//#endregion
+//#region src/kernel/deps/ensure-addon-natives.ts
+/**
+* `ensureAddonNativePrebuilds` — the POST-install native-prebuild ENSURE pass an
+* addon install runs on the INSTALLED addon dir AFTER `npm install`.
+*
+* Why this exists (Mac desktop first-boot FATAL, 2026-07-21): `installCopy`
+* copies `dist/`, plants prebuilt natives from the bundled addon copy
+* (`copyBundledNativeModules`), then `npm install`s the addon's runtime deps.
+* On a TOOLCHAIN-LESS host that `npm install` RE-CREATES the traditional native
+* `better-sqlite3` SOURCE-ONLY — clobbering the good `.node` the pre-install
+* copy just planted — and the runner later dies at addon init with a cryptic
+* "Could not locate the bindings file". The copy-BEFORE-install fix was
+* empirically insufficient: npm's own install in the copied dir replaces the
+* satisfied dep without its binary.
+*
+* This pass runs LAST, so it always sees the final on-disk state npm left, and
+* per referenced traditional native still lacking its compiled `.node`:
+*   1. bundled-copy first — if the bundled addon copy carries the matching
+*      `.node` (same machine → same platform/arch/ABI), re-plant it DIRECTLY.
+*      Cheapest + offline-safe; runs BEFORE any network fetch.
+*   2. fetch fallback — otherwise fetch the prebuild for the running ABI via the
+*      shared `ensureNativePrebuilds` pointed at the addon dir.
+*   3. FAIL LOUD — if the native is STILL source-only after both, log a clear
+*      error naming module + addon and THROW so the install fails at install
+*      time rather than at addon init.
+*
+* N-API natives (`sharp`, `node-av`) ship their binaries as ABI-stable platform
+* SIBLING packages npm fetches without a compile step, so they are excluded from
+* the default set — a miss there is a broken install, not something a prebuild
+* re-fetch heals (same rationale as `ensureNativePrebuilds`).
+*/
+/**
+* Re-plant `<srcModuleDir>` → `<dstModuleDir>` when the source carries a `.node`.
+* Returns whether the destination ends up with a compiled binary.
+*/
+function replantFromBundled(srcModuleDir, dstModuleDir, hasNative) {
+	if (!hasNative(srcModuleDir)) return false;
+	try {
+		node_fs.rmSync(dstModuleDir, {
+			recursive: true,
+			force: true
+		});
+		node_fs.mkdirSync(node_path.dirname(dstModuleDir), { recursive: true });
+		node_fs.cpSync(srcModuleDir, dstModuleDir, {
+			recursive: true,
+			dereference: true
+		});
+	} catch {
+		return false;
+	}
+	return hasNative(dstModuleDir);
+}
+/**
+* Ensure every referenced traditional native in `<addonDir>/node_modules`
+* carries its compiled `.node` after the addon's `npm install`. Bundled-copy
+* first (offline), prebuild-fetch fallback, LOUD throw on a residual miss.
+*
+* SKIPS a native absent from the addon's own `node_modules` (it resolves via a
+* hoisted host copy — not this addon's concern). A NO-OP in docker / dev where
+* npm produced a working `.node` (already-present). Returns the per-native
+* outcomes for logging/tests.
+*
+* @throws if any required native is still source-only after copy + fetch.
+*/
+async function ensureAddonNativePrebuilds(addonDir, options) {
+	const packages = options.packages ?? TRADITIONAL_NATIVE_PACKAGES;
+	const hasNative = options.hasNative ?? ((dir) => hasDotNode(dir, 4));
+	const nm = node_path.join(addonDir, "node_modules");
+	const results = [];
+	const missing = [];
+	for (const pkg of packages) {
+		const moduleDir = node_path.join(nm, pkg);
+		if (!node_fs.existsSync(moduleDir)) continue;
+		if (hasNative(moduleDir)) {
+			results.push({
+				pkg,
+				outcome: "already-present"
+			});
+			continue;
+		}
+		if (options.bundledSourceDir) {
+			const src = node_path.join(options.bundledSourceDir, "node_modules", pkg);
+			if (replantFromBundled(src, moduleDir, hasNative)) {
+				options.logger.info("addon native prebuild re-planted from bundled copy (offline)", { meta: {
+					addon: options.addonName,
+					pkg,
+					src,
+					moduleDir
+				} });
+				results.push({
+					pkg,
+					outcome: "copied"
+				});
+				continue;
+			}
+		}
+		if ((await ensureNativePrebuilds(addonDir, {
+			logger: options.logger,
+			packages: [pkg],
+			...options.target ? { target: options.target } : {},
+			...options.fetchPrebuild ? { fetchPrebuild: options.fetchPrebuild } : {}
+		})).includes(pkg)) {
+			results.push({
+				pkg,
+				outcome: "fetched"
+			});
+			continue;
+		}
+		options.logger.error("addon native prebuild MISSING after ensure — module has no compiled .node", { meta: {
+			addon: options.addonName,
+			pkg,
+			moduleDir
+		} });
+		results.push({
+			pkg,
+			outcome: "missing"
+		});
+		missing.push(pkg);
+	}
+	if (missing.length > 0) throw new Error(`${options.addonName} — required native module(s) missing a compiled .node after install (bundled-copy + prebuild-fetch both failed): ${missing.join(", ")}`);
+	return results;
+}
+//#endregion
 //#region src/kernel/addon-installer.ts
 var execFileAsync = (0, node_util.promisify)(node_child_process.execFile);
 function parseInstallSource(value) {
@@ -3318,6 +3580,7 @@ var AddonInstaller = class AddonInstaller {
 		await node_fs.promises.writeFile(node_path.join(targetDir, "package.json"), JSON.stringify(stripBundledDeps(pkgData), null, 2));
 		await copyDirRecursive(distDir, node_path.join(targetDir, "dist"));
 		await copyExtraFileDirs(pkgData, sourceDir, targetDir);
+		require_manifest_python_deps.copyBundledNativeModules(sourceDir, targetDir, this.logger);
 		await node_fs.promises.writeFile(node_path.join(targetDir, ".install-source"), "local");
 		const localPkgVersion = require_dist.asString(pkgData.version, "0.0.0");
 		this.manifest.upsert(packageName, {
@@ -3339,6 +3602,11 @@ var AddonInstaller = class AddonInstaller {
 		} catch (err) {
 			this.logger.warn(`${packageName} — native deps install failed (continuing)`, { meta: { error: require_dist.errMsg(err) } });
 		}
+		await ensureAddonNativePrebuilds(targetDir, {
+			addonName: packageName,
+			logger: this.logger,
+			bundledSourceDir: sourceDir
+		});
 		this.logger.info(`${packageName} — copied from ${sourceDir}`);
 		return {
 			name: pkgData.name,
@@ -3525,6 +3793,10 @@ var AddonInstaller = class AddonInstaller {
 			} catch (nativeErr) {
 				throw new Error(`${pkgView.name} — native deps install failed: ${require_dist.errMsg(nativeErr)}`, { cause: nativeErr });
 			}
+			await ensureAddonNativePrebuilds(pkgDir, {
+				addonName: pkgView.name,
+				logger: this.logger
+			});
 			await this.evictInstallDir(targetDir);
 			ensureDir(node_path.dirname(targetDir));
 			await node_fs.promises.rename(pkgDir, targetDir);
@@ -93463,6 +93735,7 @@ exports.LogRingBuffer = LogRingBuffer;
 exports.METHOD_ACCESS_MAP = require_dist.METHOD_ACCESS_MAP;
 exports.ModelDownloadService = require_model_download_service.ModelDownloadService;
 exports.NATIVE_PROVIDER_SERVICE_INFIX = require_manifest_python_deps.NATIVE_PROVIDER_SERVICE_INFIX;
+exports.NATIVE_SCAN_DEPTH = NATIVE_SCAN_DEPTH;
 exports.NativeMetricsAddon = require_builtins_native_metrics_native_metrics_addon.default;
 exports.NativeMetricsProvider = require_builtins_native_metrics_native_metrics_addon.NativeMetricsProvider;
 exports.NetworkQualityTracker = NetworkQualityTracker;
@@ -93494,6 +93767,7 @@ exports.StorageOrchestratorAddon = require_builtins_storage_orchestrator_storage
 exports.StorageOrchestratorService = require_builtins_storage_orchestrator_storage_orchestrator_addon.StorageOrchestratorService;
 exports.SystemConfigAddon = require_builtins_system_config_system_config_addon.SystemConfigAddon;
 exports.SystemEventBus = SystemEventBus;
+exports.TRADITIONAL_NATIVE_PACKAGES = TRADITIONAL_NATIVE_PACKAGES;
 exports.ToastService = ToastService;
 exports.UDS_NO_ROUTE_PREFIX = require_manifest_python_deps.UDS_NO_ROUTE_PREFIX;
 exports.UdsLocalTransportClient = require_manifest_python_deps.UdsLocalTransportClient;
@@ -93571,6 +93845,7 @@ exports.downloadFile = require_model_download_service.downloadFile;
 exports.downloadModel = require_model_download_service.downloadModel;
 exports.emitDownForOwnedCaps = require_dist.emitDownForOwnedCaps;
 exports.encodeFrame = require_manifest_python_deps.encodeFrame;
+exports.ensureAddonNativePrebuilds = ensureAddonNativePrebuilds;
 Object.defineProperty(exports, "ensureBinary", {
 	enumerable: true,
 	get: function() {
@@ -93586,6 +93861,7 @@ Object.defineProperty(exports, "ensureFfmpeg", {
 });
 exports.ensureLibraryBuilt = ensureLibraryBuilt;
 exports.ensureModel = require_model_download_service.ensureModel;
+exports.ensureNativePrebuilds = ensureNativePrebuilds;
 Object.defineProperty(exports, "ensurePython", {
 	enumerable: true,
 	get: function() {
@@ -93630,6 +93906,7 @@ Object.defineProperty(exports, "getPythonDownloadUrl", {
 exports.getRestartMarkerPath = getRestartMarkerPath;
 exports.getSinglePidStats = require_resource_monitor.getSinglePidStats;
 exports.getWorkerDeviceRegistry = require_manifest_python_deps.getWorkerDeviceRegistry;
+exports.hasDotNode = hasDotNode;
 exports.hashClusterSecret = hashClusterSecret;
 exports.installManifestNativeDeps = require_manifest_python_deps.installManifestNativeDeps;
 exports.installManifestPythonDeps = require_manifest_python_deps.installManifestPythonDeps;