@camstack/system 1.2.68 → 1.2.70

package/dist/builtins/device-manager/device-manager.addon.js

@@ -3,9 +3,297 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-Dhpte164.js");
-let _camstack_types_node = require("@camstack/types/node");
+const require_dist = require("../../dist-DCLoJf2T.js");
 let node_crypto = require("node:crypto");
+let _camstack_types_node = require("@camstack/types/node");
+//#region src/builtins/device-manager/adoption-job-engine.ts
+/** How many finished jobs are kept per (addonId, integrationId). */
+var JOB_HISTORY = 20;
+function snapshot(j) {
+	let adopted = 0;
+	let alreadyAdopted = 0;
+	let failed = 0;
+	let processed = 0;
+	let accessoriesCreated = 0;
+	for (const r of j.results) {
+		if (r.outcome === "cancelled") continue;
+		processed += 1;
+		accessoriesCreated += r.accessoryCount;
+		if (r.outcome === "adopted") adopted += 1;
+		else if (r.outcome === "already-adopted") alreadyAdopted += 1;
+		else if (r.outcome === "failed") failed += 1;
+	}
+	return {
+		jobId: j.jobId,
+		addonId: j.addonId,
+		integrationId: j.integrationId,
+		state: j.state,
+		total: j.total,
+		processed,
+		adopted,
+		alreadyAdopted,
+		failed,
+		accessoriesCreated,
+		currentChildNativeId: j.currentChildNativeId,
+		results: j.results.map((r) => ({
+			childNativeId: r.childNativeId,
+			outcome: r.outcome,
+			parentDeviceId: r.parentDeviceId,
+			accessoryCount: r.accessoryCount,
+			error: r.error
+		})),
+		startedAt: j.startedAt,
+		finishedAt: j.finishedAt,
+		error: j.error
+	};
+}
+var AdoptionJobEngine = class {
+	deps;
+	jobs = /* @__PURE__ */ new Map();
+	seq = 0;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	now() {
+		return this.deps.now?.() ?? Date.now();
+	}
+	newId() {
+		if (this.deps.newId) return this.deps.newId();
+		this.seq += 1;
+		return `adopt-${Date.now().toString(36)}-${this.seq}`;
+	}
+	/**
+	* Accept the batch and return immediately. The provider is resolved BEFORE
+	* returning so an unroutable `addonId` is refused at the call the operator
+	* made, not buried in a job they have to go looking for.
+	*/
+	async start(input) {
+		const provider = await this.deps.resolveProvider(input.addonId);
+		const job = {
+			jobId: this.newId(),
+			addonId: input.addonId,
+			integrationId: input.integrationId,
+			state: "running",
+			total: input.childNativeIds.length,
+			currentChildNativeId: null,
+			results: [],
+			startedAt: this.now(),
+			finishedAt: null,
+			error: null,
+			cancelRequested: false,
+			done: Promise.resolve()
+		};
+		this.jobs.set(job.jobId, job);
+		this.prune(input.addonId, input.integrationId);
+		this.deps.logger.info("adoption job started", {
+			tags: { addonId: input.addonId },
+			meta: {
+				jobId: job.jobId,
+				integrationId: input.integrationId,
+				total: job.total
+			}
+		});
+		job.done = this.run(job, provider, input);
+		return { jobId: job.jobId };
+	}
+	get(jobId) {
+		const j = this.jobs.get(jobId);
+		return j ? snapshot(j) : null;
+	}
+	list(filter) {
+		return [...this.jobs.values()].filter((j) => (filter.addonId === void 0 || j.addonId === filter.addonId) && (filter.integrationId === void 0 || j.integrationId === filter.integrationId)).sort((a, b) => b.startedAt - a.startedAt || b.jobId.localeCompare(a.jobId)).map(snapshot);
+	}
+	/** Cooperative cancel — the in-flight candidate finishes, the rest do not start. */
+	cancel(jobId) {
+		const job = this.jobs.get(jobId);
+		if (!job || job.state !== "running") return false;
+		job.cancelRequested = true;
+		this.deps.logger.info("adoption job cancel requested", {
+			tags: { addonId: job.addonId },
+			meta: {
+				jobId,
+				integrationId: job.integrationId
+			}
+		});
+		return true;
+	}
+	/** Test-only: await the detached loop. Never called by production code. */
+	async waitForTest(jobId) {
+		await this.jobs.get(jobId)?.done;
+	}
+	prune(addonId, integrationId) {
+		const finished = [...this.jobs.values()].filter((j) => j.addonId === addonId && j.integrationId === integrationId && j.state !== "running").sort((a, b) => b.startedAt - a.startedAt);
+		for (const j of finished.slice(JOB_HISTORY)) this.jobs.delete(j.jobId);
+	}
+	async run(job, provider, input) {
+		try {
+			const already = await this.alreadyAdopted(provider, input, job);
+			for (const childNativeId of input.childNativeIds) {
+				if (job.cancelRequested) {
+					job.results.push({
+						childNativeId,
+						outcome: "cancelled",
+						parentDeviceId: null,
+						accessoryCount: 0,
+						error: null
+					});
+					continue;
+				}
+				if (already.has(childNativeId)) {
+					job.results.push({
+						childNativeId,
+						outcome: "already-adopted",
+						parentDeviceId: null,
+						accessoryCount: 0,
+						error: null
+					});
+					this.deps.logger.info("adoption job: candidate already adopted, skipped", {
+						tags: { addonId: job.addonId },
+						meta: {
+							jobId: job.jobId,
+							integrationId: job.integrationId,
+							childNativeId
+						}
+					});
+					continue;
+				}
+				job.currentChildNativeId = childNativeId;
+				await this.adoptOne(job, provider, input, childNativeId);
+				job.currentChildNativeId = null;
+			}
+			job.state = job.cancelRequested ? "cancelled" : "done";
+		} catch (err) {
+			job.state = "failed";
+			job.error = require_dist.errMsg(err);
+			this.deps.logger.error("adoption job failed", {
+				tags: { addonId: job.addonId },
+				meta: {
+					jobId: job.jobId,
+					integrationId: job.integrationId,
+					error: job.error
+				}
+			});
+		} finally {
+			job.currentChildNativeId = null;
+			job.finishedAt = this.now();
+			const s = snapshot(job);
+			this.deps.logger.info("adoption job finished", {
+				tags: { addonId: job.addonId },
+				meta: {
+					jobId: job.jobId,
+					integrationId: job.integrationId,
+					state: s.state,
+					total: s.total,
+					adopted: s.adopted,
+					alreadyAdopted: s.alreadyAdopted,
+					failed: s.failed,
+					accessoriesCreated: s.accessoriesCreated,
+					durationMs: (s.finishedAt ?? 0) - s.startedAt
+				}
+			});
+		}
+	}
+	/**
+	* One `listCandidates` snapshot at job start. A read that FAILS must not be
+	* read as "nothing is adopted" — that would send every candidate to the
+	* provider and turn a safe retry back into a wall of duplicate-stableId
+	* errors — so a failure yields an empty set AND a warning, and the
+	* per-candidate failure path stays the backstop.
+	*/
+	async alreadyAdopted(provider, input, job) {
+		try {
+			const page = await provider.listCandidates({
+				integrationId: input.integrationId,
+				page: 1,
+				pageSize: 2e4,
+				...input.filter !== void 0 ? { filter: input.filter } : {}
+			});
+			const out = /* @__PURE__ */ new Set();
+			for (const c of page.candidates) if (c.alreadyAdopted === true) out.add(c.childNativeId);
+			return out;
+		} catch (err) {
+			this.deps.logger.warn("adoption job: pre-flight listCandidates failed — every candidate will be attempted", {
+				tags: { addonId: job.addonId },
+				meta: {
+					jobId: job.jobId,
+					integrationId: job.integrationId,
+					error: require_dist.errMsg(err)
+				}
+			});
+			return /* @__PURE__ */ new Set();
+		}
+	}
+	async adoptOne(job, provider, input, childNativeId) {
+		const startedAt = this.now();
+		try {
+			const per = input.perCandidate?.[childNativeId];
+			const entry = (await provider.adopt({
+				integrationId: input.integrationId,
+				childNativeIds: [childNativeId],
+				...input.filter !== void 0 ? { filter: input.filter } : {},
+				...input.importLocations !== void 0 ? { importLocations: input.importLocations } : {},
+				...per !== void 0 ? { perCandidate: { [childNativeId]: per } } : {}
+			})).adopted[0];
+			if (!entry) {
+				job.results.push({
+					childNativeId,
+					outcome: "failed",
+					parentDeviceId: null,
+					accessoryCount: 0,
+					error: "provider returned no adopted entry"
+				});
+				this.deps.logger.warn("adoption job: provider adopted nothing for candidate", {
+					tags: { addonId: job.addonId },
+					meta: {
+						jobId: job.jobId,
+						integrationId: job.integrationId,
+						childNativeId
+					}
+				});
+				return;
+			}
+			job.results.push({
+				childNativeId,
+				outcome: "adopted",
+				parentDeviceId: entry.parentDeviceId,
+				accessoryCount: entry.accessoryDeviceIds.length,
+				error: null
+			});
+			this.deps.logger.info("adoption job: candidate adopted", {
+				tags: {
+					deviceId: entry.parentDeviceId,
+					addonId: job.addonId
+				},
+				meta: {
+					jobId: job.jobId,
+					integrationId: job.integrationId,
+					childNativeId,
+					accessories: entry.accessoryDeviceIds.length,
+					durationMs: this.now() - startedAt
+				}
+			});
+		} catch (err) {
+			job.results.push({
+				childNativeId,
+				outcome: "failed",
+				parentDeviceId: null,
+				accessoryCount: 0,
+				error: require_dist.errMsg(err)
+			});
+			this.deps.logger.warn("adoption job: candidate failed", {
+				tags: { addonId: job.addonId },
+				meta: {
+					jobId: job.jobId,
+					integrationId: job.integrationId,
+					childNativeId,
+					durationMs: this.now() - startedAt,
+					error: require_dist.errMsg(err)
+				}
+			});
+		}
+	}
+};
+//#endregion
 //#region src/builtins/device-manager/day-night-config-schema.ts
 var MODE_LABELS = {
 	auto: "Auto",
@@ -1128,6 +1416,27 @@ async function adoptionRelease(pctx, input) {
 	const { addonId, ...rest } = input;
 	return (await pctx.host.requireDeviceAdoptionProvider(addonId)).release(rest);
 }
+async function adoptionStartJob(pctx, input) {
+	const { addonId, integrationId, childNativeIds, filter, importLocations, perCandidate } = input;
+	return pctx.host.adoptionJobs.start({
+		addonId,
+		integrationId,
+		childNativeIds,
+		...filter !== void 0 ? { filter } : {},
+		...importLocations !== void 0 ? { importLocations } : {},
+		...perCandidate !== void 0 ? { perCandidate } : {}
+	});
+}
+async function adoptionListJobs(pctx, input) {
+	const { addonId, integrationId } = input;
+	return pctx.host.adoptionJobs.list({
+		addonId,
+		...integrationId !== void 0 ? { integrationId } : {}
+	});
+}
+async function adoptionCancelJob(pctx, input) {
+	return { cancelled: pctx.host.adoptionJobs.cancel(input.jobId) };
+}
 async function adoptionResync(pctx, input) {
 	const { camDeviceId, resetToSource } = input;
 	let owningAddonId = pctx.registry?.getAddonId(camDeviceId) ?? null;
@@ -3929,6 +4238,8 @@ var DeviceManagerAddon = class extends require_dist.BaseAddon {
 	* the D3 re-handshake after device restore is the reliable replacement.
 	*/
 	remoteNativeCaps = /* @__PURE__ */ new Map();
+	/** Background adoption jobs — lazily constructed (needs `ctx.logger`). */
+	adoptionJobEngine = null;
 	/** The runtime-state mirror, asserted present (constructed in onInitialize). */
 	get stateMirror() {
 		if (!this.stateMirrorImpl) throw new Error("DeviceManagerAddon: state mirror accessed before onInitialize");
@@ -3954,9 +4265,22 @@ var DeviceManagerAddon = class extends require_dist.BaseAddon {
 			resolveDeviceProbed: (deviceId) => this.stateMirror.resolveDeviceProbed(deviceId),
 			waitDeviceProvider: (addonId, timeoutMs) => this.waitDeviceProvider(addonId, timeoutMs),
 			requireDeviceProvider: (addonId) => this.requireDeviceProvider(addonId),
-			requireDeviceAdoptionProvider: (addonId) => this.requireDeviceAdoptionProvider(addonId)
+			requireDeviceAdoptionProvider: (addonId) => this.requireDeviceAdoptionProvider(addonId),
+			adoptionJobs: this.adoptionJobsImpl
 		};
 	}
+	/**
+	* Background adoption jobs. In-RAM and process-lifetime: a restart forgets
+	* them, which is safe because adoption is keyed by a stable id — re-running a
+	* job re-adopts nothing (see `AdoptionJobEngine`).
+	*/
+	get adoptionJobsImpl() {
+		if (!this.adoptionJobEngine) this.adoptionJobEngine = new AdoptionJobEngine({
+			resolveProvider: async (addonId) => this.requireDeviceAdoptionProvider(addonId),
+			logger: this.ctx.logger
+		});
+		return this.adoptionJobEngine;
+	}
 	/** Wait for a device-provider by addonId, returning null on timeout. */
 	async waitDeviceProvider(addonId, timeoutMs = 5e3) {
 		const provider = await this.capabilityRegistry?.waitForProvider("device-provider", addonId, timeoutMs);
@@ -4136,6 +4460,9 @@ var DeviceManagerAddon = class extends require_dist.BaseAddon {
 			adoptionRefresh: (input) => adoptionRefresh(pctx, input),
 			adoptionAdopt: (input) => adoptionAdopt(pctx, input),
 			adoptionRelease: (input) => adoptionRelease(pctx, input),
+			adoptionStartJob: (input) => adoptionStartJob(pctx, input),
+			adoptionListJobs: (input) => adoptionListJobs(pctx, input),
+			adoptionCancelJob: (input) => adoptionCancelJob(pctx, input),
 			adoptionResync: (input) => adoptionResync(pctx, input),
 			discoveryProviders: async () => {
 				return { providers: (await this.listDiscoveryCapableProviderIds()).map((addonId) => ({