@camstack/system 1.1.24 → 1.1.26

package/dist/builtins/platform-probe/index.mjs

@@ -1,5 +1,5 @@
 import * as fs from "node:fs";
-import { BaseAddon, EventCategory, errMsg, platformProbeCapability, scoreRuntimes } from "@camstack/types";
+import { BaseAddon, EventCategory, emitReadiness, errMsg, platformProbeCapability, scoreRuntimes } from "@camstack/types";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import * as os from "node:os";
@@ -11,7 +11,7 @@ import * as os from "node:os";
 * entire Node process (WS handshakes, tRPC subscriptions, metrics — all
 * stalled). Keeping it async turns the probe into a true background task.
 */
-var execFileAsync$2 = promisify(execFile);
+var execFileAsync = promisify(execFile);
 /** Minimal no-op logger for default parameter */
 var noopLogger = {
 	debug() {},
@@ -39,7 +39,7 @@ async function getAvailableRAM_MB() {
 		const platform = os.platform();
 		try {
 			if (platform === "darwin") {
-				const { stdout: output } = await execFileAsync$2("vm_stat", [], {
+				const { stdout: output } = await execFileAsync("vm_stat", [], {
 					encoding: "utf8",
 					timeout: 3e3
 				});
@@ -164,7 +164,7 @@ var PlatformScorer = class {
 		}
 		if (platform === "linux") {
 			try {
-				const { stdout } = await execFileAsync$2("nvidia-smi", ["--query-gpu=name,memory.total", "--format=csv,noheader"], {
+				const { stdout } = await execFileAsync("nvidia-smi", ["--query-gpu=name,memory.total", "--format=csv,noheader"], {
 					encoding: "utf8",
 					timeout: 5e3
 				});
@@ -230,7 +230,7 @@ var PlatformScorer = class {
 			"python"
 		];
 		for (const cmd of candidates) try {
-			await execFileAsync$2(cmd, ["--version"], { timeout: 5e3 });
+			await execFileAsync(cmd, ["--version"], { timeout: 5e3 });
 			return cmd;
 		} catch (err) {
 			this.logger.debug(`Python command "${cmd}" not found`, { meta: { error: errMsg(err) } });
@@ -328,296 +328,91 @@ var InferenceConfigResolver = class {
 	}
 };
 //#endregion
-//#region src/builtins/platform-probe/hardware-encoder-probe.ts
-var execFileAsync$1 = promisify(execFile);
-function buildCandidates(hardware) {
-	const out = [];
-	if (hardware.platform === "darwin") {
-		out.push({
-			encoder: "h264_videotoolbox",
-			codec: "H264",
-			family: "videotoolbox"
-		});
-		out.push({
-			encoder: "hevc_videotoolbox",
-			codec: "H265",
-			family: "videotoolbox"
-		});
-	}
-	if (hardware.platform === "linux") {
-		if (hardware.gpu?.type === "nvidia") {
-			out.push({
-				encoder: "h264_nvenc",
-				codec: "H264",
-				family: "nvenc"
-			});
-			out.push({
-				encoder: "hevc_nvenc",
-				codec: "H265",
-				family: "nvenc"
-			});
-		}
-		if (hardware.gpu?.type === "intel" || hardware.gpu?.type === "amd" || !hardware.gpu) {
-			out.push({
-				encoder: "h264_vaapi",
-				codec: "H264",
-				family: "vaapi"
-			});
-			out.push({
-				encoder: "hevc_vaapi",
-				codec: "H265",
-				family: "vaapi"
-			});
-		}
-	}
-	return out;
-}
-async function runTestEncode(candidate, opts) {
-	const ffmpeg = opts.ffmpegPath ?? "ffmpeg";
-	const timeout = opts.timeoutMs ?? 8e3;
-	const nullSink = os.platform() === "win32" ? "NUL" : "/dev/null";
-	const baseArgs = [
-		"-hide_banner",
-		"-loglevel",
-		"error"
-	];
-	const inArgs = [
-		"-f",
-		"lavfi",
-		"-i",
-		"testsrc=duration=0.04:size=16x16:rate=25"
-	];
-	let outArgs;
-	if (candidate.family === "vaapi") outArgs = [
-		"-vaapi_device",
-		"/dev/dri/renderD128",
-		"-vf",
-		"format=nv12,hwupload",
-		"-c:v",
-		candidate.encoder,
-		"-frames:v",
-		"1",
-		"-f",
-		"null",
-		nullSink
-	];
-	else outArgs = [
-		"-c:v",
-		candidate.encoder,
-		"-frames:v",
-		"1",
-		"-f",
-		"null",
-		nullSink
-	];
-	try {
-		await execFileAsync$1(ffmpeg, [
-			...baseArgs,
-			...inArgs,
-			...outArgs
-		], {
-			timeout,
-			encoding: "utf8"
-		});
-		return {
-			encoder: candidate.encoder,
-			codec: candidate.codec,
-			family: candidate.family,
-			available: true
-		};
-	} catch (err) {
-		return {
-			encoder: candidate.encoder,
-			codec: candidate.codec,
-			family: candidate.family,
-			available: false,
-			reason: errMsg(err)
-		};
-	}
-}
-var HardwareEncoderProber = class {
-	cached = null;
-	inflight = null;
-	logger;
-	ffmpegPath;
-	constructor(logger, ffmpegPath = "ffmpeg") {
-		this.logger = logger;
-		this.ffmpegPath = ffmpegPath;
-	}
-	getCached() {
-		return this.cached;
-	}
-	async probe(hardware, options = {}) {
-		if (!options.force && this.cached) return this.cached;
-		if (this.inflight) return this.inflight;
-		this.inflight = this.runProbe(hardware).then((res) => {
-			this.cached = res;
-			this.inflight = null;
-			return res;
-		}).catch((err) => {
-			this.inflight = null;
-			throw err;
-		});
-		return this.inflight;
-	}
-	async runProbe(hardware) {
-		const candidates = buildCandidates(hardware);
-		const start = Date.now();
-		this.logger.info("Probing hardware encoders", { meta: {
-			platform: hardware.platform,
-			arch: hardware.arch,
-			candidates: candidates.length
-		} });
-		const probes = await Promise.all(candidates.map((c) => runTestEncode(c, { ffmpegPath: this.ffmpegPath })));
-		probes.push({
-			encoder: "libx264",
-			codec: "H264",
-			family: "software",
-			available: true
-		});
-		probes.push({
-			encoder: "libx265",
-			codec: "H265",
-			family: "software",
-			available: true
-		});
-		const pickDefault = (codec) => {
-			const hw = probes.find((p) => p.codec === codec && p.available && p.family !== "software");
-			if (hw) return hw.encoder;
-			return codec === "H264" ? "libx264" : "libx265";
-		};
-		const result = {
-			encoders: probes,
-			defaultH264: pickDefault("H264"),
-			defaultH265: pickDefault("H265"),
-			probedAt: Date.now()
-		};
-		const elapsed = Date.now() - start;
-		this.logger.info("Hardware encoder probe complete", { meta: {
-			elapsedMs: elapsed,
-			defaultH264: result.defaultH264,
-			defaultH265: result.defaultH265,
-			availableHw: probes.filter((p) => p.available && p.family !== "software").map((p) => p.encoder)
-		} });
-		return result;
-	}
-};
-//#endregion
-//#region src/builtins/platform-probe/hardware-decode-accel-probe.ts
-var execFileAsync = promisify(execFile);
-var defaultExecFn = async (ffmpegPath, args) => {
-	const { stdout } = await execFileAsync(ffmpegPath, [...args], {
-		timeout: 8e3,
-		encoding: "utf8"
-	});
-	return { stdout };
-};
+//#region src/builtins/platform-probe/index.ts
 /**
-* Parse the output of `ffmpeg -hwaccels`. The listing looks like:
-*
-*   Hardware acceleration methods:
-*   videotoolbox
-*
-* The header line is dropped; remaining non-empty trimmed lines are the
-* method names, lowercased and de-duplicated (order preserved).
+* The decode-hwaccel backends `ctx.kernel.hwaccel.resolve` accepts. The cap
+* input enum is WIDER (it also carries EP-only names — coreml/openvino/… —
+* shared with other probe surfaces), so the provider param must stay
+* `string`-typed to satisfy the `InferProvider` contract. We narrow it here
+* with a type guard instead of a cast: any value that is not a known decode
+* backend (or the `'none'` sentinel) resolves to `null` → auto-probe.
 */
-function parseHwAccelsOutput(stdout) {
-	const seen = /* @__PURE__ */ new Set();
-	const methods = [];
-	for (const raw of stdout.split("\n")) {
-		const line = raw.trim().toLowerCase();
-		if (line.length === 0) continue;
-		if (line.endsWith("methods:")) continue;
-		if (seen.has(line)) continue;
-		seen.add(line);
-		methods.push(line);
-	}
-	return methods;
+var HWACCEL_DECODE_BACKENDS = [
+	"videotoolbox",
+	"cuda",
+	"nvdec",
+	"vaapi",
+	"qsv",
+	"d3d11va",
+	"dxva2",
+	"amf",
+	"vdpau",
+	"drm"
+];
+function isHwAccelBackend(value) {
+	return HWACCEL_DECODE_BACKENDS.includes(value);
+}
+function narrowHwAccelPrefer(value) {
+	if (value === "none") return "none";
+	if (typeof value === "string" && isHwAccelBackend(value)) return value;
+	return null;
 }
-/**
-* Probes which `-hwaccel` decode backends the configured ffmpeg binary
-* supports. Mirrors {@link HardwareEncoderProber} (configured binary, cached,
-* single-flight, forceable). Never throws: a probe failure yields an empty
-* method list so callers fall back to software decode.
-*/
-var HardwareDecodeAccelProber = class {
-	cached = null;
-	inflight = null;
-	logger;
-	ffmpegPath;
-	execFn;
-	constructor(logger, ffmpegPath = "ffmpeg", execFn = defaultExecFn) {
-		this.logger = logger;
-		this.ffmpegPath = ffmpegPath;
-		this.execFn = execFn;
-	}
-	getCached() {
-		return this.cached;
-	}
-	async probe(options = {}) {
-		if (!options.force && this.cached) return this.cached;
-		if (this.inflight) return this.inflight;
-		this.inflight = this.runProbe().then((res) => {
-			this.cached = res;
-			this.inflight = null;
-			return res;
-		}).catch((err) => {
-			this.inflight = null;
-			throw err;
-		});
-		return this.inflight;
-	}
-	async runProbe() {
-		try {
-			const { stdout } = await this.execFn(this.ffmpegPath, ["-hide_banner", "-hwaccels"]);
-			const methods = parseHwAccelsOutput(stdout);
-			this.logger.info("Hardware decode-accel probe complete", { meta: { methods } });
-			return {
-				methods,
-				probedAt: Date.now()
-			};
-		} catch (err) {
-			this.logger.warn("Hardware decode-accel probe failed — assuming none available", { meta: { error: errMsg(err) } });
-			return {
-				methods: [],
-				probedAt: Date.now()
-			};
-		}
-	}
-};
-//#endregion
-//#region src/builtins/platform-probe/index.ts
 var PlatformProbeNativeAddon = class extends BaseAddon {
 	scorer = null;
-	encoderProber = null;
-	decodeAccelProber = null;
 	cachedCaps = null;
+	/**
+	* Per-boot generation stamp for the manual readiness emissions below.
+	* Constant for the lifetime of this addon instance (== one process boot);
+	* consumer-side registries derive a monotonic epoch from generation
+	* transitions. Mirrors `BaseAddon._readinessGeneration` (private there).
+	*/
+	readinessGeneration = typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : Math.random().toString(36).slice(2, 14);
 	constructor() {
 		super({});
 	}
 	/**
-	* Resolve the ffmpeg binary the encoder probe should test, from the cluster
-	* `ffmpeg` config section (`binaryPath`). The probe MUST exercise the same
-	* binary the broker/recorder spawn, or it may report encoders for a different
-	* ffmpeg. Defaults to PATH `ffmpeg` on any miss.
+	* Manual readiness protocol. The provider registers synchronously from
+	* `onInitialize`, but the REAL hardware + EP scoring is the async
+	* `probePromise` (embedded-Python install included). The BaseAddon
+	* auto-emit would flip `ready` at registration time — BEFORE any
+	* accelerator is visible — so probe-gated consumers (detection-pipeline
+	* engine auto-pick) would read accelerator-blind results and stick on
+	* onnx-CPU. Instead: `starting` at init, the single authoritative
+	* `ready` once the probe resolves, `down` on shutdown.
 	*/
-	async resolveFfmpegBinaryPath() {
+	get autoEmitReadiness() {
+		return false;
+	}
+	/** Bare cluster node id — readiness is scoped `{type:'node', nodeId}`. */
+	bareLocalNodeId() {
+		const raw = this.ctx.kernel?.localNodeId ?? "hub";
+		return raw.includes("/") ? raw.split("/")[0] : raw;
+	}
+	/** Emit a `system.ready-state` transition for the platform-probe cap. */
+	emitProbeReadiness(state) {
+		const ctx = this.ctxIfReady;
+		if (!ctx) return;
+		const nodeId = this.bareLocalNodeId();
 		try {
-			const bp = (await this.ctx.settings?.getSection("ffmpeg") ?? {})["binaryPath"];
-			return typeof bp === "string" && bp.trim().length > 0 ? bp : "ffmpeg";
-		} catch {
-			return "ffmpeg";
-		}
+			emitReadiness(ctx.eventBus, {
+				capName: platformProbeCapability.name,
+				scope: {
+					type: "node",
+					nodeId
+				},
+				state,
+				generation: this.readinessGeneration,
+				sourceNodeId: nodeId
+			});
+		} catch {}
 	}
 	async onInitialize() {
+		this.emitProbeReadiness("starting");
 		const embeddedPython = await this.ctx.deps.ensurePython().catch((err) => {
 			this.ctx.logger.debug("ensurePython unavailable for platform probe", { meta: { error: errMsg(err) } });
 			return null;
 		});
 		this.scorer = new PlatformScorer(this.ctx.logger, embeddedPython);
-		const ffmpegPath = await this.resolveFfmpegBinaryPath();
-		this.encoderProber = new HardwareEncoderProber(this.ctx.logger, ffmpegPath);
-		this.decodeAccelProber = new HardwareDecodeAccelProber(this.ctx.logger, ffmpegPath);
 		const emitPhase = (phase, payload) => {
 			this.ctx.eventBus?.emit({
 				id: `platform-probe-${phase}-${Date.now()}`,
@@ -644,6 +439,7 @@ var PlatformProbeNativeAddon = class extends BaseAddon {
 				bestReason: caps.bestScore.reason,
 				bestScore: caps.bestScore.score
 			} });
+			this.emitProbeReadiness("ready");
 			return caps;
 		}).catch((err) => {
 			const msg = errMsg(err);
@@ -669,42 +465,24 @@ var PlatformProbeNativeAddon = class extends BaseAddon {
 				},
 				resolveHwAccel: async (input) => {
 					const hwaccel = this.ctx.kernel.hwaccel;
-					if (!hwaccel) return { preferred: [] };
-					return { preferred: (await hwaccel.resolve(input.prefer ?? null)).preferred };
-				},
-				getHardwareEncoders: async () => {
-					const prober = this.encoderProber;
-					if (!prober) throw new Error("Hardware encoder prober not initialized");
-					const cached = prober.getCached();
-					if (cached) return cached;
-					const caps = await getCaps();
-					return prober.probe(caps.hardware);
-				},
-				refreshHardwareEncoders: async () => {
-					const prober = this.encoderProber;
-					if (!prober) throw new Error("Hardware encoder prober not initialized");
-					const caps = await getCaps();
-					return prober.probe(caps.hardware, { force: true });
-				},
-				getHardwareDecodeAccels: async () => {
-					const prober = this.decodeAccelProber;
-					if (!prober) throw new Error("Hardware decode-accel prober not initialized");
-					return prober.probe();
-				},
-				refreshHardwareDecodeAccels: async () => {
-					const prober = this.decodeAccelProber;
-					if (!prober) throw new Error("Hardware decode-accel prober not initialized");
-					return prober.probe({ force: true });
+					if (!hwaccel) return {
+						preferred: [],
+						rationale: "kernel hwaccel unavailable"
+					};
+					const res = await hwaccel.resolve(narrowHwAccelPrefer(input.prefer));
+					return {
+						preferred: res.preferred,
+						rationale: res.rationale
+					};
 				}
 			}
 		}];
 	}
 	async onShutdown() {
+		this.emitProbeReadiness("down");
 		this.scorer = null;
-		this.encoderProber = null;
-		this.decodeAccelProber = null;
 		this.cachedCaps = null;
 	}
 };
 //#endregion
-export { HardwareDecodeAccelProber, HardwareEncoderProber, InferenceConfigResolver, PlatformProbeNativeAddon, PlatformProbeNativeAddon as default, PlatformScorer };
+export { InferenceConfigResolver, PlatformProbeNativeAddon, PlatformProbeNativeAddon as default, PlatformScorer };

package/dist/builtins/system-config/system-config.addon.js

@@ -44,8 +44,7 @@ let _camstack_types = require("@camstack/types");
 /** Section key → user-facing section title. */
 var SECTION_TITLES = {
 	server: "Server",
-	auth: "Authentication",
-	ffmpeg: "FFmpeg"
+	auth: "Authentication"
 };
 /** Keys that map 1:1 to a given yml section — used by `updateGlobalSettings`
 *  to figure out which section owns each key in the incoming patch. */
@@ -53,10 +52,7 @@ var KEY_TO_SECTION = {
 	port: "server",
 	host: "server",
 	dataPath: "server",
-	tokenExpiry: "auth",
-	binaryPath: "ffmpeg",
-	hwAccel: "ffmpeg",
-	threadCount: "ffmpeg"
+	tokenExpiry: "auth"
 };
 var SystemConfigAddon = class extends _camstack_types.BaseAddon {
 	id = "system-config";
@@ -67,119 +63,56 @@ var SystemConfigAddon = class extends _camstack_types.BaseAddon {
 		this.ctx.logger.info("Initialized — exposes yml-backed sections via getGlobalSettings");
 	}
 	buildGlobalSchema() {
-		return { sections: [
-			{
-				id: "system-config-server",
-				title: SECTION_TITLES["server"],
-				description: "Core server connection settings — read-only, loaded from config.yaml at bootstrap.",
-				columns: 2,
-				fields: [
-					{
-						type: "info",
-						key: "server-restart-note",
-						label: "Restart required",
-						content: "Server settings are read-only. Change them in config.yaml and restart.",
-						variant: "warning"
-					},
-					{
-						type: "text",
-						key: "port",
-						label: "Port",
-						description: "Listening port",
-						disabled: true
-					},
-					{
-						type: "text",
-						key: "host",
-						label: "Host",
-						description: "Bind address",
-						disabled: true
-					},
-					{
-						type: "text",
-						key: "dataPath",
-						label: "Data Path",
-						description: "Root data directory",
-						disabled: true,
-						span: 2
-					}
-				]
-			},
-			{
-				id: "system-config-auth",
-				title: SECTION_TITLES["auth"],
-				description: "Token and session settings.",
-				columns: 1,
-				fields: [{
+		return { sections: [{
+			id: "system-config-server",
+			title: SECTION_TITLES["server"],
+			description: "Core server connection settings — read-only, loaded from config.yaml at bootstrap.",
+			columns: 2,
+			fields: [
+				{
+					type: "info",
+					key: "server-restart-note",
+					label: "Restart required",
+					content: "Server settings are read-only. Change them in config.yaml and restart.",
+					variant: "warning"
+				},
+				{
 					type: "text",
-					key: "tokenExpiry",
-					label: "Token Expiry",
-					description: "JWT token lifetime (e.g. 24h, 7d, 1h)",
-					placeholder: "24h",
-					default: "24h"
-				}]
-			},
-			{
-				id: "system-config-ffmpeg",
-				title: SECTION_TITLES["ffmpeg"],
-				description: "FFmpeg binary and hardware acceleration settings.",
-				columns: 2,
-				fields: [
-					{
-						type: "text",
-						key: "binaryPath",
-						label: "Binary Path",
-						description: "Path to ffmpeg executable",
-						placeholder: "ffmpeg",
-						default: "ffmpeg",
-						span: 2
-					},
-					{
-						type: "select",
-						key: "hwAccel",
-						label: "Hardware Acceleration",
-						description: "GPU decoding/encoding backend",
-						default: "auto",
-						options: [
-							{
-								value: "auto",
-								label: "Auto-detect"
-							},
-							{
-								value: "none",
-								label: "None (CPU only)"
-							},
-							{
-								value: "videotoolbox",
-								label: "VideoToolbox (macOS)"
-							},
-							{
-								value: "vaapi",
-								label: "VA-API (Linux Intel/AMD)"
-							},
-							{
-								value: "qsv",
-								label: "QSV (Intel Quick Sync)"
-							},
-							{
-								value: "cuda",
-								label: "CUDA (NVIDIA)"
-							}
-						]
-					},
-					{
-						type: "number",
-						key: "threadCount",
-						label: "Thread Count",
-						description: "0 = auto (let FFmpeg decide)",
-						min: 0,
-						max: 16,
-						step: 1,
-						default: 0
-					}
-				]
-			}
-		] };
+					key: "port",
+					label: "Port",
+					description: "Listening port",
+					disabled: true
+				},
+				{
+					type: "text",
+					key: "host",
+					label: "Host",
+					description: "Bind address",
+					disabled: true
+				},
+				{
+					type: "text",
+					key: "dataPath",
+					label: "Data Path",
+					description: "Root data directory",
+					disabled: true,
+					span: 2
+				}
+			]
+		}, {
+			id: "system-config-auth",
+			title: SECTION_TITLES["auth"],
+			description: "Token and session settings.",
+			columns: 1,
+			fields: [{
+				type: "text",
+				key: "tokenExpiry",
+				label: "Token Expiry",
+				description: "JWT token lifetime (e.g. 24h, 7d, 1h)",
+				placeholder: "24h",
+				default: "24h"
+			}]
+		}] };
 	}
 	async getGlobalSettings() {
 		const schema = this.buildGlobalSchema();