@camstack/system 1.0.2

package/dist/network/network-quality.d.ts

@@ -0,0 +1,11 @@
+import { StreamNetworkStats, ClientNetworkStats, DeviceNetworkStats, INetworkQualityTracker } from '@camstack/types';
+export type { StreamNetworkStats, ClientNetworkStats, DeviceNetworkStats, INetworkQualityTracker };
+export declare class NetworkQualityTracker implements INetworkQualityTracker {
+    private readonly devices;
+    private static readonly MAX_SAMPLES;
+    reportStreamStats(deviceId: number, streamId: string, bitrateKbps: number, packetLoss?: number): void;
+    reportClientStats(deviceId: number, stats: Omit<ClientNetworkStats, 'lastUpdated'>): void;
+    getDeviceStats(deviceId: number): DeviceNetworkStats | null;
+    getAllStats(): readonly DeviceNetworkStats[];
+    private getOrCreateDevice;
+}

package/dist/notification/notification-service.d.ts

@@ -0,0 +1,37 @@
+import { INotificationOutput, Notification, ICapabilityRegistry } from '@camstack/types';
+import { IScopedLogger } from '../logging/scoped-logger.js';
+/**
+ * Central notification service that routes notifications to configured outputs.
+ * Framework-agnostic — dependencies injected via constructor.
+ *
+ * Outputs are resolved from the ICapabilityRegistry's 'notification-output'
+ * collection on each call (proxy pattern). Falls back to a local map
+ * when no registry is provided (backward compat).
+ */
+export declare class NotificationService {
+    private readonly logger;
+    private readonly localOutputs;
+    private readonly routing;
+    private readonly rateLimits;
+    private readonly lastSent;
+    private registry;
+    constructor(logger: IScopedLogger);
+    /** Set the registry for live output lookup. Called once during boot. */
+    setRegistry(registry: ICapabilityRegistry): void;
+    /** Resolve all outputs — prefers registry, falls back to local map */
+    private get outputs();
+    /** Register an output in the local fallback map (used when no registry is set). */
+    registerLocalOutput(output: INotificationOutput): void;
+    /** Remove an output from the local fallback map. */
+    unregisterLocalOutput(id: string): void;
+    setRouting(category: string, outputIds: string[]): void;
+    setRateLimit(category: string, minIntervalMs: number): void;
+    notify(notification: Notification): Promise<void>;
+    getOutputs(): ReadonlyArray<{
+        id: string;
+        name: string;
+        icon: string;
+    }>;
+    getRouting(): ReadonlyMap<string, string[]>;
+    getOutput(id: string): INotificationOutput | undefined;
+}

package/dist/notification/toast-service.d.ts

@@ -0,0 +1,22 @@
+import { Toast } from '@camstack/types';
+export type Unsubscribe = () => void;
+/**
+ * Service for broadcasting toast notifications to connected UI clients.
+ * Framework-agnostic — integrates with tRPC subscriptions via subscribe().
+ */
+export declare class ToastService {
+    private readonly listeners;
+    /**
+     * Subscribe to toast events for a specific user.
+     * Returns an unsubscribe function.
+     */
+    subscribe(connectionId: string, userId: string, callback: (toast: Toast) => void): Unsubscribe;
+    /**
+     * Broadcast a toast to all connected clients.
+     */
+    broadcast(toast: Toast): void;
+    /**
+     * Send a toast to a specific user's connections only.
+     */
+    sendToUser(userId: string, toast: Toast): void;
+}

package/dist/pipeline/engine-manager-resolver.d.ts

@@ -0,0 +1,15 @@
+import { IAddonResolver, IAddonCaller, IEngineManager } from '@camstack/types';
+/**
+ * Adapter that wraps an IEngineManager + addonConfigs as an IAddonResolver.
+ *
+ * Used for backwards compatibility — the in-process AddonEngineManager
+ * still uses the old getOrCreateEngine(addonId, globalConfig, override) API.
+ * This adapter bridges it to the new resolve(addonId, config) interface.
+ */
+export declare class EngineManagerResolver implements IAddonResolver {
+    private readonly engineManager;
+    private readonly addonConfigs;
+    constructor(engineManager: IEngineManager, addonConfigs: Map<string, Record<string, unknown>>);
+    resolve(addonId: string, config: Record<string, unknown>): Promise<IAddonCaller>;
+    shutdownAll(): Promise<void>;
+}

package/dist/pipeline/pipeline-runner.d.ts

@@ -0,0 +1,8 @@
+import { FrameInput, PipelineConfig, PipelineResult, IAddonResolver } from '@camstack/types';
+export declare class PipelineRunner {
+    private readonly addonResolver;
+    constructor(addonResolver: IAddonResolver);
+    run(frame: FrameInput, config: PipelineConfig): Promise<PipelineResult>;
+    private executeNode;
+    private executeChildren;
+}

package/dist/pipeline/pipeline-validator.d.ts

@@ -0,0 +1,13 @@
+import { PipelineConfig, ValidationIssue, ValidationResult } from '@camstack/types';
+export type { ValidationIssue, ValidationResult };
+/**
+ * Check if a pipeline step is available in the system.
+ * Implementations should check the capability registry for `pipeline-step:{stepId}`.
+ */
+export type StepExistsFn = (stepId: string) => boolean;
+export declare class PipelineValidator {
+    private readonly stepExists;
+    constructor(stepExists: StepExistsFn);
+    validate(config: PipelineConfig): ValidationResult;
+    private validateNode;
+}

package/dist/process/resource-monitor.d.ts

@@ -0,0 +1,11 @@
+export interface PidStats {
+    cpu: number;
+    memory: number;
+}
+/**
+ * Get CPU% and memory RSS for one or more PIDs.
+ * Returns a map of pid → stats. Missing/dead PIDs are silently omitted.
+ */
+export declare function getPidStats(pids: number | readonly number[]): Promise<ReadonlyMap<number, PidStats>>;
+/** Get CPU% and memory RSS for a single PID. Returns null if dead. */
+export declare function getSinglePidStats(pid: number): Promise<PidStats | null>;

package/dist/python/python-env-manager.d.ts

@@ -0,0 +1,12 @@
+import { IPythonEnvironment, PythonProbeResult, PythonEnvReady } from '@camstack/types';
+import { ChildProcess } from 'node:child_process';
+export declare class PythonEnvManager implements IPythonEnvironment {
+    private venvPath;
+    private cachedProbe;
+    constructor(dataDir: string);
+    probe(): Promise<PythonProbeResult>;
+    ensure(options: {
+        packages: readonly string[];
+    }): Promise<PythonEnvReady>;
+    spawn(script: string, args: readonly string[]): ChildProcess;
+}

package/dist/repl/interfaces.d.ts

@@ -0,0 +1,31 @@
+import { ReplResult } from '@camstack/types';
+export interface ReplScope {
+    readonly type: 'system' | 'provider' | 'device' | 'addon';
+    readonly providerId?: string;
+    readonly deviceId?: number;
+    readonly addonId?: string;
+}
+export interface ReplSessionContext {
+    readonly scope: ReplScope;
+    /** Pre-populated variables available in the REPL session */
+    readonly variables: Record<string, unknown>;
+}
+export type { ReplResult };
+export interface IReplEngine {
+    execute(code: string, context: ReplSessionContext): Promise<ReplResult>;
+    getCompletions(partial: string, context: ReplSessionContext): Promise<string[]>;
+}
+/**
+ * Context provider that the server kernel implements.
+ * The REPL engine calls this to build the sandbox for each scope type.
+ *
+ * Methods may return a Promise so the kernel can warm up async
+ * resources (e.g. `SystemManager.init()`) before exposing them — the
+ * engine awaits each before evaluating user code.
+ */
+export interface IReplContextProvider {
+    getSystemSandbox(): Record<string, unknown> | Promise<Record<string, unknown>>;
+    getDeviceSandbox(deviceId: number): Record<string, unknown> | Promise<Record<string, unknown>>;
+    getProviderSandbox(providerId: string): Record<string, unknown> | Promise<Record<string, unknown>>;
+    getAddonSandbox(addonId: string): Record<string, unknown> | Promise<Record<string, unknown>>;
+}

package/dist/repl/repl-engine.d.ts

@@ -0,0 +1,8 @@
+import { IReplEngine, IReplContextProvider, ReplSessionContext, ReplResult } from './interfaces.js';
+export declare class ReplEngine implements IReplEngine {
+    private readonly contextProvider;
+    constructor(contextProvider: IReplContextProvider);
+    execute(code: string, context: ReplSessionContext): Promise<ReplResult>;
+    getCompletions(partial: string, context: ReplSessionContext): Promise<string[]>;
+    private buildSandbox;
+}

package/dist/resource-monitor-ClDGFyf6.mjs

@@ -0,0 +1,57 @@
+import { r as __exportAll } from "./chunk-CNf5ZN-e.mjs";
+import { execFile } from "node:child_process";
+//#region src/process/resource-monitor.ts
+var resource_monitor_exports = /* @__PURE__ */ __exportAll({
+	getPidStats: () => getPidStats,
+	getSinglePidStats: () => getSinglePidStats
+});
+function execPsForPids(pids) {
+	return new Promise((resolve, reject) => {
+		execFile("ps", [
+			"-o",
+			"pid=,pcpu=,rss=",
+			"-p",
+			pids.join(",")
+		], { timeout: 5e3 }, (err, stdout) => {
+			if (err) return reject(err);
+			resolve(stdout);
+		});
+	});
+}
+function parsePsOutput(stdout) {
+	const result = /* @__PURE__ */ new Map();
+	for (const line of stdout.trim().split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		const parts = trimmed.split(/\s+/);
+		if (parts.length < 3) continue;
+		const pid = parseInt(parts[0], 10);
+		const cpu = parseFloat(parts[1]);
+		const rssKb = parseInt(parts[2], 10);
+		if (isNaN(pid) || isNaN(cpu) || isNaN(rssKb)) continue;
+		result.set(pid, {
+			cpu: Math.round(cpu * 10) / 10,
+			memory: rssKb * 1024
+		});
+	}
+	return result;
+}
+/**
+* Get CPU% and memory RSS for one or more PIDs.
+* Returns a map of pid → stats. Missing/dead PIDs are silently omitted.
+*/
+async function getPidStats(pids) {
+	const pidArray = typeof pids === "number" ? [pids] : [...pids];
+	if (pidArray.length === 0) return /* @__PURE__ */ new Map();
+	try {
+		return parsePsOutput(await execPsForPids(pidArray));
+	} catch {
+		return /* @__PURE__ */ new Map();
+	}
+}
+/** Get CPU% and memory RSS for a single PID. Returns null if dead. */
+async function getSinglePidStats(pid) {
+	return (await getPidStats([pid])).get(pid) ?? null;
+}
+//#endregion
+export { getSinglePidStats as n, resource_monitor_exports as r, getPidStats as t };

package/dist/resource-monitor-IIEanuJt.js

@@ -0,0 +1,74 @@
+const require_chunk = require("./chunk-Cek0wNdY.js");
+let node_child_process = require("node:child_process");
+//#region src/process/resource-monitor.ts
+var resource_monitor_exports = /* @__PURE__ */ require_chunk.__exportAll({
+	getPidStats: () => getPidStats,
+	getSinglePidStats: () => getSinglePidStats
+});
+function execPsForPids(pids) {
+	return new Promise((resolve, reject) => {
+		(0, node_child_process.execFile)("ps", [
+			"-o",
+			"pid=,pcpu=,rss=",
+			"-p",
+			pids.join(",")
+		], { timeout: 5e3 }, (err, stdout) => {
+			if (err) return reject(err);
+			resolve(stdout);
+		});
+	});
+}
+function parsePsOutput(stdout) {
+	const result = /* @__PURE__ */ new Map();
+	for (const line of stdout.trim().split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		const parts = trimmed.split(/\s+/);
+		if (parts.length < 3) continue;
+		const pid = parseInt(parts[0], 10);
+		const cpu = parseFloat(parts[1]);
+		const rssKb = parseInt(parts[2], 10);
+		if (isNaN(pid) || isNaN(cpu) || isNaN(rssKb)) continue;
+		result.set(pid, {
+			cpu: Math.round(cpu * 10) / 10,
+			memory: rssKb * 1024
+		});
+	}
+	return result;
+}
+/**
+* Get CPU% and memory RSS for one or more PIDs.
+* Returns a map of pid → stats. Missing/dead PIDs are silently omitted.
+*/
+async function getPidStats(pids) {
+	const pidArray = typeof pids === "number" ? [pids] : [...pids];
+	if (pidArray.length === 0) return /* @__PURE__ */ new Map();
+	try {
+		return parsePsOutput(await execPsForPids(pidArray));
+	} catch {
+		return /* @__PURE__ */ new Map();
+	}
+}
+/** Get CPU% and memory RSS for a single PID. Returns null if dead. */
+async function getSinglePidStats(pid) {
+	return (await getPidStats([pid])).get(pid) ?? null;
+}
+//#endregion
+Object.defineProperty(exports, "getPidStats", {
+	enumerable: true,
+	get: function() {
+		return getPidStats;
+	}
+});
+Object.defineProperty(exports, "getSinglePidStats", {
+	enumerable: true,
+	get: function() {
+		return getSinglePidStats;
+	}
+});
+Object.defineProperty(exports, "resource_monitor_exports", {
+	enumerable: true,
+	get: function() {
+		return resource_monitor_exports;
+	}
+});

package/dist/settle-sources-Bhsy57y-.js

@@ -0,0 +1,38 @@
+//#region src/builtins/shared/settle-sources.ts
+/** Reject with a timeout error if `p` hasn't settled within `ms`. */
+async function withTimeout(p, ms, label) {
+	let timer;
+	const timeout = new Promise((_, reject) => {
+		timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`source '${label}' timed out after ${ms}ms`)), ms);
+	});
+	try {
+		return await Promise.race([p, timeout]);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+function toError(err) {
+	return err instanceof Error ? err : new Error(String(err));
+}
+async function settleSourcesWithTimeout(entries, timeoutMs) {
+	return Promise.all(entries.map(async ([id, call]) => {
+		try {
+			return [id, {
+				ok: true,
+				value: await withTimeout(Promise.resolve().then(call), timeoutMs, id)
+			}];
+		} catch (err) {
+			return [id, {
+				ok: false,
+				error: toError(err)
+			}];
+		}
+	}));
+}
+//#endregion
+Object.defineProperty(exports, "settleSourcesWithTimeout", {
+	enumerable: true,
+	get: function() {
+		return settleSourcesWithTimeout;
+	}
+});

package/dist/settle-sources-CDtNC8ub.mjs

@@ -0,0 +1,33 @@
+//#region src/builtins/shared/settle-sources.ts
+/** Reject with a timeout error if `p` hasn't settled within `ms`. */
+async function withTimeout(p, ms, label) {
+	let timer;
+	const timeout = new Promise((_, reject) => {
+		timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`source '${label}' timed out after ${ms}ms`)), ms);
+	});
+	try {
+		return await Promise.race([p, timeout]);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+function toError(err) {
+	return err instanceof Error ? err : new Error(String(err));
+}
+async function settleSourcesWithTimeout(entries, timeoutMs) {
+	return Promise.all(entries.map(async ([id, call]) => {
+		try {
+			return [id, {
+				ok: true,
+				value: await withTimeout(Promise.resolve().then(call), timeoutMs, id)
+			}];
+		} catch (err) {
+			return [id, {
+				ok: false,
+				error: toError(err)
+			}];
+		}
+	}));
+}
+//#endregion
+export { settleSourcesWithTimeout as t };

package/dist/storage/fs-storage-backend.d.ts

@@ -0,0 +1,40 @@
+export interface IStorageBackend {
+    /** Backend type identifier */
+    readonly type: string;
+    /** Base path of this backend */
+    readonly basePath: string;
+    /** Resolve a subpath to an absolute path */
+    resolve(subpath: string): string;
+    /**
+     * Check whether the backend is usable: either the base directory
+     * already exists and is writable, OR we can create it on first
+     * write (i.e. the nearest existing ancestor is writable).
+     */
+    isAvailable(): boolean;
+    /** No-op for lazy backends. Kept for API compatibility. */
+    initialize(): Promise<void>;
+}
+/**
+ * Filesystem storage backend — lazy by design.
+ *
+ * `initialize()` does NOT create the base directory eagerly. Instead,
+ * consumers that write via `FilesystemStorageProvider` (and other write
+ * helpers in storage-manager.ts) run `fs.mkdir(dirname(filePath), { recursive: true })`
+ * right before every `writeFile`, so the directory tree appears on demand.
+ *
+ * The previous behaviour eagerly mkdir'd every location declared in
+ * `StorageLocationManager.initializeDefaults()` — six directories (`db`,
+ * `media`, `recordings`, `models`, `cache`, `logs`) got created at boot
+ * even if the installation had no cameras, no recording addon, no
+ * analytics addon, etc. That meant every fresh install looked like it
+ * was producing data when it had nothing to write. Laziness fixes that:
+ * a directory only exists once an addon decides to put a file there.
+ */
+export declare class FsStorageBackend implements IStorageBackend {
+    readonly type = "local";
+    readonly basePath: string;
+    constructor(basePath: string);
+    resolve(subpath: string): string;
+    isAvailable(): boolean;
+    initialize(): Promise<void>;
+}

package/dist/storage/storage-location-manager.d.ts

@@ -0,0 +1,23 @@
+import { IStorageBackend } from './fs-storage-backend.js';
+export type StorageLocationName = 'data' | 'media' | 'recordings' | 'models' | 'cache' | 'logs';
+export declare class StorageLocationManager {
+    private readonly backends;
+    private readonly dataPath;
+    constructor(dataPath: string);
+    /** Initialize all locations with default paths */
+    initializeDefaults(): Promise<void>;
+    /** Override a specific location's backend path */
+    setLocationPath(name: StorageLocationName, basePath: string): Promise<void>;
+    /** Get the backend for a location */
+    getBackend(name: StorageLocationName): IStorageBackend;
+    /** Resolve a path within a location */
+    resolve(location: StorageLocationName, subpath: string): string;
+    /** Check if all locations are available */
+    getStatus(): Array<{
+        name: StorageLocationName;
+        available: boolean;
+        path: string;
+    }>;
+    /** All location names */
+    getLocationNames(): StorageLocationName[];
+}

package/dist/storage/storage-manager.d.ts

@@ -0,0 +1,83 @@
+import { StorageLocationManager, StorageLocationName } from './storage-location-manager.js';
+import { IStorageProvider as INewStorageProvider, ISettingsBackend, HistogramBucket } from '@camstack/types';
+export interface IStorageProvider {
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    getLocation(name: StorageLocationName): IStorageLocation;
+    export?(locationName: StorageLocationName): Promise<Buffer>;
+    import?(locationName: StorageLocationName, data: Buffer): Promise<void>;
+}
+export interface QueryFilter {
+    where?: Record<string, unknown>;
+    whereIn?: Record<string, unknown[]>;
+    whereBetween?: Record<string, [unknown, unknown]>;
+    orderBy?: {
+        field: string;
+        direction: 'asc' | 'desc';
+    };
+    limit?: number;
+    offset?: number;
+}
+export interface StorageRecord {
+    collection: string;
+    id: string;
+    data: Record<string, unknown>;
+}
+export interface IStructuredStorage {
+    query(collection: string, filter?: QueryFilter): Promise<readonly StorageRecord[]>;
+    insert(record: StorageRecord): Promise<StorageRecord>;
+    update(collection: string, id: string, data: Record<string, unknown>): Promise<StorageRecord>;
+    delete(collection: string, id: string): Promise<void>;
+    count(collection: string, filter?: QueryFilter): Promise<number>;
+    histogram(input: {
+        collection: string;
+        field: string;
+        bucketSize: number;
+        origin: number;
+        filter?: QueryFilter;
+    }): Promise<readonly HistogramBucket[]>;
+}
+export interface IFileStorage {
+    readFile(path: string): Promise<Buffer>;
+    writeFile(path: string, data: Buffer): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    listFiles(prefix?: string): Promise<readonly string[]>;
+    getFileUrl(path: string): Promise<string>;
+    exists(path: string): Promise<boolean>;
+}
+export interface IStorageLocation {
+    structured?: IStructuredStorage;
+    files?: IFileStorage;
+}
+/**
+ * StorageManager — bridge between legacy code (getLocation/getLocationPath)
+ * and the new capability-based storage system.
+ *
+ * Legacy consumers call getLocation('addon', namespace) to get structured + file storage.
+ * This manager builds the response from:
+ *   - SettingsBackend (for structured queries) — provided by sqlite-settings addon
+ *   - LocationManager (for file paths) — set during Phase 2 boot
+ */
+export declare class StorageManager {
+    private legacyProvider;
+    private locationManager;
+    private newStorageProvider;
+    private settingsBackend;
+    /** @deprecated Set by legacy capability consumer — use setNewStorageProvider instead */
+    setProvider(provider: IStorageProvider | INewStorageProvider): void;
+    setNewStorageProvider(provider: INewStorageProvider): void;
+    setSettingsBackend(backend: ISettingsBackend): void;
+    getSettingsBackend(): ISettingsBackend;
+    getProvider(): IStorageProvider;
+    setLocationManager(manager: StorageLocationManager): void;
+    getLocationManager(): StorageLocationManager;
+    initializeLocations(dataPath: string): Promise<void>;
+    getLocationPath(name: StorageLocationName): string;
+    /**
+     * Get a storage location with optional namespace scoping.
+     * Builds IStorageLocation from settingsBackend (structured) + locationManager (files).
+     */
+    getLocation(name: StorageLocationName | string, namespace?: string): IStorageLocation;
+    private createLegacyShim;
+    private createNamespacedLocation;
+}