@camstack/system 1.0.2

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

@@ -0,0 +1,226 @@
+import { BaseAddon, errMsg, hydrateSchema } from "@camstack/types";
+//#region src/builtins/system-config/system-config.addon.ts
+/**
+* Built-in `system-config` addon — Phase 4 of the settings redesign.
+*
+* Exposes the cluster-wide yml-backed sections that the bootstrap
+* loader reads before any addon is instantiated — things that cannot
+* live inside an addon because changing them requires a server
+* restart (port, host, dataPath) or because they own no runtime
+* state of their own (auth token expiry, global ffmpeg binary path).
+*
+* Sections exposed:
+*   - server     (port, host, dataPath — READ-ONLY, loaded from config.yaml at bootstrap)
+*   - auth       (tokenExpiry)
+*   - ffmpeg     (binaryPath, hwAccel, threadCount)
+*
+* Sections NOT exposed (each owned by the addon that implements them):
+*   - logging    → `winston-logging` addon (level + retention)
+*   - recording  → `recording` addon (segment duration, retention)
+*   - retention  → analytics / detection addons (per-table retention)
+*
+* Implementation notes:
+*   - Runs only on the hub process (yml sections are hub-side state).
+*     On agent nodes this addon would still instantiate, but every
+*     `ctx.settings.getSection(section)` call would hit an empty
+*     ConfigManager section so the UI would show the schema defaults.
+*     In practice the built-in loader can skip it on agents; for now we
+*     just let it run everywhere because it's harmless.
+*   - Reads via `ctx.settings.getSection(section)` and writes via
+*     `ctx.settings.setSection(section, patch)` — the explicit
+*     yml-section pair on `AddonSettingsApi`.
+*   - Does NOT register as a capability provider. It's a pure "settings
+*     surface" addon — its sole purpose is to expose the yml sections
+*     through the new three-level settings API.
+*
+* This addon is declared in `@camstack/system`'s package.json `camstack.addons[]`
+* and loaded automatically via AddonLoader like any other core built-in.
+*/
+/** Section key → user-facing section title. */
+var SECTION_TITLES = {
+	server: "Server",
+	auth: "Authentication",
+	ffmpeg: "FFmpeg"
+};
+/** 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. */
+var KEY_TO_SECTION = {
+	port: "server",
+	host: "server",
+	dataPath: "server",
+	tokenExpiry: "auth",
+	binaryPath: "ffmpeg",
+	hwAccel: "ffmpeg",
+	threadCount: "ffmpeg"
+};
+var SystemConfigAddon = class extends BaseAddon {
+	id = "system-config";
+	constructor() {
+		super({});
+	}
+	async onInitialize() {
+		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: [{
+					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
+					}
+				]
+			}
+		] };
+	}
+	async getGlobalSettings() {
+		const schema = this.buildGlobalSchema();
+		if (!this.ctx.settings) return hydrateSchema(schema, {});
+		const sectionNames = Object.keys(SECTION_TITLES);
+		const merged = {};
+		for (const section of sectionNames) try {
+			const values = await this.ctx.settings.getSection(section);
+			Object.assign(merged, values);
+		} catch (err) {
+			const msg = errMsg(err);
+			this.ctx.logger.debug("Failed to read section", { meta: {
+				section,
+				error: msg
+			} });
+		}
+		return hydrateSchema(schema, merged);
+	}
+	async updateGlobalSettings(patch) {
+		if (!this.ctx.settings) throw new Error("system-config: ctx.settings not available — cannot write sections");
+		const perSection = /* @__PURE__ */ new Map();
+		for (const [key, value] of Object.entries(patch)) {
+			const section = KEY_TO_SECTION[key];
+			if (section === void 0) {
+				this.ctx.logger.warn("update ignored unknown key (not mapped to any section)", { meta: { key } });
+				continue;
+			}
+			if (section === "server") {
+				this.ctx.logger.warn("update ignored read-only server-section key", { meta: { key } });
+				continue;
+			}
+			let bucket = perSection.get(section);
+			if (!bucket) {
+				bucket = {};
+				perSection.set(section, bucket);
+			}
+			bucket[key] = value;
+		}
+		for (const [section, sectionPatch] of perSection) {
+			await this.ctx.settings.setSection(section, sectionPatch);
+			this.ctx.logger.info("Wrote keys to section", { meta: {
+				section,
+				keyCount: Object.keys(sectionPatch).length
+			} });
+		}
+	}
+};
+//#endregion
+export { SystemConfigAddon, SystemConfigAddon as default };

package/dist/builtins/winston-logging/index.d.ts

@@ -0,0 +1,3 @@
+export { WinstonLoggingAddon } from './winston-logging.addon.js';
+export { WinstonDestination } from './winston-destination.js';
+export { WinstonLoggingAddon as default } from './winston-logging.addon.js';

package/dist/builtins/winston-logging/index.js

@@ -0,0 +1,156 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_chunk = require("../../chunk-Cek0wNdY.js");
+const require_formatter = require("../../formatter-DqAKDlvN.js");
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let _camstack_types = require("@camstack/types");
+let winston = require("winston");
+winston = require_chunk.__toESM(winston);
+let winston_daily_rotate_file = require("winston-daily-rotate-file");
+winston_daily_rotate_file = require_chunk.__toESM(winston_daily_rotate_file);
+//#region src/builtins/winston-logging/winston-destination.ts
+/**
+* Rotated-file log destination. Console output goes through the shared
+* `formatLogLine` so every console sink (Winston, ConsoleDestination,
+* HubForwarderDestination) emits identical lines. File output keeps a
+* structured JSON shape so log tooling can query tags/meta.
+*/
+var WinstonDestination = class {
+	logger = null;
+	async initialize(config) {
+		const { level = "info", retentionDays = 30, logsDir = node_path.join("camstack-data", "logs") } = config ?? {};
+		winston.format.printf((info) => {
+			const rendered = info._rendered;
+			return typeof rendered === "string" ? rendered : String(info.message);
+		});
+		const stripRendered = winston.format((info) => {
+			delete info["_rendered"];
+			return info;
+		});
+		const fileFormat = winston.format.combine(winston.format.timestamp(), stripRendered(), winston.format.json());
+		this.logger = winston.createLogger({
+			level,
+			transports: [new winston_daily_rotate_file.default({
+				dirname: logsDir,
+				filename: "camstack-%DATE%.log",
+				datePattern: "YYYY-MM-DD",
+				maxFiles: `${retentionDays}d`,
+				format: fileFormat
+			})]
+		});
+	}
+	write(entry) {
+		if (!this.logger) return;
+		const ts = entry.timestamp instanceof Date ? entry.timestamp.toISOString() : String(entry.timestamp);
+		const rendered = require_formatter.formatLogLine(entry, { colorize: true });
+		this.logger.log({
+			level: entry.level,
+			message: entry.message,
+			_rendered: rendered,
+			timestamp: ts,
+			scope: entry.scope,
+			...entry.tags ? { tags: entry.tags } : {},
+			...entry.meta ? { meta: entry.meta } : {}
+		});
+	}
+	async query(_filter) {
+		return [];
+	}
+	async shutdown() {
+		if (!this.logger) return;
+		await new Promise((resolve) => {
+			this.logger.on("finish", resolve);
+			this.logger.end();
+		});
+		this.logger = null;
+	}
+};
+//#endregion
+//#region src/builtins/winston-logging/winston-logging.addon.ts
+/**
+* Winston logging addon — rotated log files + console output.
+* Settings appear under Cluster → NodeDetail → Settings.
+*/
+var WinstonLoggingAddon = class extends _camstack_types.BaseAddon {
+	destination = null;
+	constructor() {
+		super({
+			level: "info",
+			retentionDays: 30
+		});
+	}
+	async onInitialize() {
+		const logsDir = await this.ctx.api.storage.resolve.query({
+			location: "logs",
+			relativePath: ""
+		}).catch(() => "camstack-data/logs");
+		this.destination = new WinstonDestination();
+		await this.destination.initialize({
+			...this.config,
+			logsDir
+		});
+		this.ctx.logger.info("Winston logging initialized");
+		return [{
+			capability: _camstack_types.logDestinationCapability,
+			provider: this.destination
+		}];
+	}
+	async onShutdown() {
+		await this.destination?.shutdown();
+	}
+	getDestination() {
+		if (!this.destination) throw new Error("Winston not initialized");
+		return this.destination;
+	}
+	globalSettingsSchema() {
+		return this.schema({ sections: [{
+			id: "winston-logging",
+			title: "Logging",
+			description: "Global log verbosity + retention for rotated log files on this node.",
+			columns: 2,
+			fields: [this.field({
+				type: "select",
+				key: "level",
+				label: "Log Level",
+				default: "info",
+				options: [
+					{
+						value: "debug",
+						label: "Debug"
+					},
+					{
+						value: "info",
+						label: "Info"
+					},
+					{
+						value: "warn",
+						label: "Warn"
+					},
+					{
+						value: "error",
+						label: "Error"
+					}
+				]
+			}), this.field({
+				type: "number",
+				key: "retentionDays",
+				label: "Retention (days)",
+				description: "Number of days to keep rotated log files before deletion",
+				min: 1,
+				max: 365,
+				step: 1,
+				default: 30,
+				unit: "days"
+			})]
+		}] });
+	}
+};
+//#endregion
+exports.WinstonDestination = WinstonDestination;
+exports.WinstonDestination$1 = WinstonDestination;
+exports.WinstonLoggingAddon = WinstonLoggingAddon;
+exports.WinstonLoggingAddon$1 = WinstonLoggingAddon;
+exports.default = WinstonLoggingAddon;

package/dist/builtins/winston-logging/index.mjs

@@ -0,0 +1,144 @@
+import { t as formatLogLine } from "../../formatter-B7qW8bPJ.mjs";
+import * as path$1 from "node:path";
+import { BaseAddon, logDestinationCapability } from "@camstack/types";
+import * as winston from "winston";
+import DailyRotateFile from "winston-daily-rotate-file";
+//#region src/builtins/winston-logging/winston-destination.ts
+/**
+* Rotated-file log destination. Console output goes through the shared
+* `formatLogLine` so every console sink (Winston, ConsoleDestination,
+* HubForwarderDestination) emits identical lines. File output keeps a
+* structured JSON shape so log tooling can query tags/meta.
+*/
+var WinstonDestination = class {
+	logger = null;
+	async initialize(config) {
+		const { level = "info", retentionDays = 30, logsDir = path$1.join("camstack-data", "logs") } = config ?? {};
+		winston.format.printf((info) => {
+			const rendered = info._rendered;
+			return typeof rendered === "string" ? rendered : String(info.message);
+		});
+		const stripRendered = winston.format((info) => {
+			delete info["_rendered"];
+			return info;
+		});
+		const fileFormat = winston.format.combine(winston.format.timestamp(), stripRendered(), winston.format.json());
+		this.logger = winston.createLogger({
+			level,
+			transports: [new DailyRotateFile({
+				dirname: logsDir,
+				filename: "camstack-%DATE%.log",
+				datePattern: "YYYY-MM-DD",
+				maxFiles: `${retentionDays}d`,
+				format: fileFormat
+			})]
+		});
+	}
+	write(entry) {
+		if (!this.logger) return;
+		const ts = entry.timestamp instanceof Date ? entry.timestamp.toISOString() : String(entry.timestamp);
+		const rendered = formatLogLine(entry, { colorize: true });
+		this.logger.log({
+			level: entry.level,
+			message: entry.message,
+			_rendered: rendered,
+			timestamp: ts,
+			scope: entry.scope,
+			...entry.tags ? { tags: entry.tags } : {},
+			...entry.meta ? { meta: entry.meta } : {}
+		});
+	}
+	async query(_filter) {
+		return [];
+	}
+	async shutdown() {
+		if (!this.logger) return;
+		await new Promise((resolve) => {
+			this.logger.on("finish", resolve);
+			this.logger.end();
+		});
+		this.logger = null;
+	}
+};
+//#endregion
+//#region src/builtins/winston-logging/winston-logging.addon.ts
+/**
+* Winston logging addon — rotated log files + console output.
+* Settings appear under Cluster → NodeDetail → Settings.
+*/
+var WinstonLoggingAddon = class extends BaseAddon {
+	destination = null;
+	constructor() {
+		super({
+			level: "info",
+			retentionDays: 30
+		});
+	}
+	async onInitialize() {
+		const logsDir = await this.ctx.api.storage.resolve.query({
+			location: "logs",
+			relativePath: ""
+		}).catch(() => "camstack-data/logs");
+		this.destination = new WinstonDestination();
+		await this.destination.initialize({
+			...this.config,
+			logsDir
+		});
+		this.ctx.logger.info("Winston logging initialized");
+		return [{
+			capability: logDestinationCapability,
+			provider: this.destination
+		}];
+	}
+	async onShutdown() {
+		await this.destination?.shutdown();
+	}
+	getDestination() {
+		if (!this.destination) throw new Error("Winston not initialized");
+		return this.destination;
+	}
+	globalSettingsSchema() {
+		return this.schema({ sections: [{
+			id: "winston-logging",
+			title: "Logging",
+			description: "Global log verbosity + retention for rotated log files on this node.",
+			columns: 2,
+			fields: [this.field({
+				type: "select",
+				key: "level",
+				label: "Log Level",
+				default: "info",
+				options: [
+					{
+						value: "debug",
+						label: "Debug"
+					},
+					{
+						value: "info",
+						label: "Info"
+					},
+					{
+						value: "warn",
+						label: "Warn"
+					},
+					{
+						value: "error",
+						label: "Error"
+					}
+				]
+			}), this.field({
+				type: "number",
+				key: "retentionDays",
+				label: "Retention (days)",
+				description: "Number of days to keep rotated log files before deletion",
+				min: 1,
+				max: 365,
+				step: 1,
+				default: 30,
+				unit: "days"
+			})]
+		}] });
+	}
+};
+//#endregion
+export { WinstonDestination, WinstonLoggingAddon, WinstonLoggingAddon as default };

package/dist/builtins/winston-logging/winston-destination.d.ts

@@ -0,0 +1,21 @@
+import { ILogDestination, LogEntry, LogFilter } from '@camstack/types';
+interface WinstonConfig {
+    readonly level: string;
+    readonly retentionDays: number;
+    /** Resolved absolute path to the logs directory (replaces the old dataPath field). */
+    readonly logsDir: string;
+}
+/**
+ * Rotated-file log destination. Console output goes through the shared
+ * `formatLogLine` so every console sink (Winston, ConsoleDestination,
+ * HubForwarderDestination) emits identical lines. File output keeps a
+ * structured JSON shape so log tooling can query tags/meta.
+ */
+export declare class WinstonDestination implements ILogDestination {
+    private logger;
+    initialize(config?: WinstonConfig): Promise<void>;
+    write(entry: LogEntry): void;
+    query(_filter: LogFilter): Promise<readonly LogEntry[]>;
+    shutdown(): Promise<void>;
+}
+export {};

package/dist/builtins/winston-logging/winston-logging.addon.d.ts

@@ -0,0 +1,19 @@
+import { ProviderRegistration, BaseAddon } from '@camstack/types';
+import { WinstonDestination } from './winston-destination.js';
+interface WinstonConfig {
+    readonly level: string;
+    readonly retentionDays: number;
+}
+/**
+ * Winston logging addon — rotated log files + console output.
+ * Settings appear under Cluster → NodeDetail → Settings.
+ */
+export declare class WinstonLoggingAddon extends BaseAddon<WinstonConfig> {
+    private destination;
+    constructor();
+    protected onInitialize(): Promise<ProviderRegistration[]>;
+    protected onShutdown(): Promise<void>;
+    getDestination(): WinstonDestination;
+    protected globalSettingsSchema(): import('@camstack/types').ConfigUISchema;
+}
+export {};

package/dist/chunk-CNf5ZN-e.mjs

@@ -0,0 +1,37 @@
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
+export { __toCommonJS as a, __require as i, __esmMin as n, __toESM as o, __exportAll as r, __commonJSMin as t };

package/dist/chunk-Cek0wNdY.js

@@ -0,0 +1,64 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+//#endregion
+Object.defineProperty(exports, "__commonJSMin", {
+	enumerable: true,
+	get: function() {
+		return __commonJSMin;
+	}
+});
+Object.defineProperty(exports, "__esmMin", {
+	enumerable: true,
+	get: function() {
+		return __esmMin;
+	}
+});
+Object.defineProperty(exports, "__exportAll", {
+	enumerable: true,
+	get: function() {
+		return __exportAll;
+	}
+});
+Object.defineProperty(exports, "__toCommonJS", {
+	enumerable: true,
+	get: function() {
+		return __toCommonJS;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});