@camstack/system 1.0.2

package/dist/builtins/device-manager/index.d.ts

@@ -0,0 +1,2 @@
+export { DeviceManagerAddon } from './device-manager.addon.js';
+export { default } from './device-manager.addon.js';

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

@@ -0,0 +1,8 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+require("../../chunk-Cek0wNdY.js");
+const require_builtins_device_manager_device_manager_addon = require("./device-manager.addon.js");
+exports.DeviceManagerAddon = require_builtins_device_manager_device_manager_addon.DeviceManagerAddon;
+exports.default = require_builtins_device_manager_device_manager_addon.DeviceManagerAddon;

package/dist/builtins/device-manager/index.mjs

@@ -0,0 +1,2 @@
+import { DeviceManagerAddon } from "./device-manager.addon.mjs";
+export { DeviceManagerAddon, DeviceManagerAddon as default };

package/dist/builtins/hub-forwarder/hub-forwarder-destination.d.ts

@@ -0,0 +1,44 @@
+import { IClusterBroker, ILogDestination, IScopedLogger, LogEntry, LogFilter } from '@camstack/types';
+/**
+ * Log destination for agent mode.
+ *
+ * - Writes to console ONLY when hub is not yet reachable (cold-start
+ *   fallback). Forked-worker agents share stdout with their parent
+ *   hub, so logging to local console AND forwarding to hub's
+ *   `log-receiver` would print the entry twice on the hub terminal.
+ *   Once the hub is discovered, local console output stops and the
+ *   hub's own ConsoleDestination owns the render.
+ * - When a Moleculer broker is connected and the hub node is reachable,
+ *   forwards every log entry to the hub via `log-receiver.ingest`.
+ * - Entries written before the hub is reachable are buffered internally
+ *   (ring-buffered to `DEFAULT_OUTBOUND_BUFFER_SIZE`) and flushed on connect,
+ *   so boot-time logs still reach the hub without any external replay trigger.
+ */
+export declare class HubForwarderDestination implements ILogDestination {
+    private broker;
+    private hubConnected;
+    private readonly outboundBuffer;
+    private statusLogger;
+    initialize(): Promise<void>;
+    /**
+     * Provide a logger for the destination's own status messages
+     * (discovery, disconnect, reconnect). Routed through the agent's
+     * LogManager but never through this same destination — the owning
+     * addon must hand in a logger that does NOT route back here, or
+     * status writes will recurse.
+     */
+    setStatusLogger(logger: IScopedLogger): void;
+    private status;
+    /**
+     * Attach the Moleculer broker so hub forwarding can start.
+     * Called by the owning addon from `onInitialize(ctx)` with
+     * `ctx.kernel.cluster?.broker`.
+     */
+    connectBroker(broker: IClusterBroker): void;
+    write(entry: LogEntry): void;
+    query(_filter: LogFilter): Promise<readonly LogEntry[]>;
+    shutdown(): Promise<void>;
+    private bufferOutbound;
+    private flushOutbound;
+    private forward;
+}

package/dist/builtins/hub-forwarder/hub-forwarder.addon.d.ts

@@ -0,0 +1,15 @@
+import { ProviderRegistration, BaseAddon } from '@camstack/types';
+import { HubForwarderDestination } from './hub-forwarder-destination.js';
+/**
+ * Agent-only addon that provides the `log-destination` capability.
+ * Writes all logs to the console and forwards to the hub via Moleculer when
+ * reachable. The broker is read from `ctx.kernel.cluster?.broker`; outbound
+ * log replay on hub-connect is handled internally by the destination.
+ */
+export declare class HubForwarderAddon extends BaseAddon {
+    private destination;
+    constructor();
+    protected onInitialize(): Promise<ProviderRegistration[]>;
+    getDestination(): HubForwarderDestination | null;
+    protected onShutdown(): Promise<void>;
+}

package/dist/builtins/hub-forwarder/index.d.ts

@@ -0,0 +1,3 @@
+export { HubForwarderAddon } from './hub-forwarder.addon.js';
+export { HubForwarderAddon as default } from './hub-forwarder.addon.js';
+export { HubForwarderDestination } from './hub-forwarder-destination.js';

package/dist/builtins/hub-forwarder/index.js

@@ -0,0 +1,154 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+require("../../chunk-Cek0wNdY.js");
+const require_formatter = require("../../formatter-DqAKDlvN.js");
+let _camstack_types = require("@camstack/types");
+//#region src/builtins/hub-forwarder/hub-forwarder-destination.ts
+var DEFAULT_OUTBOUND_BUFFER_SIZE = 500;
+/**
+* Log destination for agent mode.
+*
+* - Writes to console ONLY when hub is not yet reachable (cold-start
+*   fallback). Forked-worker agents share stdout with their parent
+*   hub, so logging to local console AND forwarding to hub's
+*   `log-receiver` would print the entry twice on the hub terminal.
+*   Once the hub is discovered, local console output stops and the
+*   hub's own ConsoleDestination owns the render.
+* - When a Moleculer broker is connected and the hub node is reachable,
+*   forwards every log entry to the hub via `log-receiver.ingest`.
+* - Entries written before the hub is reachable are buffered internally
+*   (ring-buffered to `DEFAULT_OUTBOUND_BUFFER_SIZE`) and flushed on connect,
+*   so boot-time logs still reach the hub without any external replay trigger.
+*/
+var HubForwarderDestination = class {
+	broker = null;
+	hubConnected = false;
+	outboundBuffer = [];
+	statusLogger = null;
+	async initialize() {}
+	/**
+	* Provide a logger for the destination's own status messages
+	* (discovery, disconnect, reconnect). Routed through the agent's
+	* LogManager but never through this same destination — the owning
+	* addon must hand in a logger that does NOT route back here, or
+	* status writes will recurse.
+	*/
+	setStatusLogger(logger) {
+		this.statusLogger = logger;
+	}
+	status(level, msg) {
+		if (this.statusLogger) {
+			if (level === "warn") this.statusLogger.warn(msg);
+			else this.statusLogger.info(msg);
+			return;
+		}
+		if (level === "warn") console.warn(`[hub-forwarder] ${msg}`);
+		else console.log(`[hub-forwarder] ${msg}`);
+	}
+	/**
+	* Attach the Moleculer broker so hub forwarding can start.
+	* Called by the owning addon from `onInitialize(ctx)` with
+	* `ctx.kernel.cluster?.broker`.
+	*/
+	connectBroker(broker) {
+		this.broker = broker;
+		broker.waitForServices("log-receiver").then(() => {
+			this.hubConnected = true;
+			this.status("info", "log-receiver discovered — log forwarding active");
+			this.flushOutbound();
+		}).catch(() => {});
+		broker.localBus.on("$node.disconnected", ({ node }) => {
+			if (node.id === "hub") {
+				this.hubConnected = false;
+				this.status("info", "Hub disconnected — log forwarding paused");
+				broker.waitForServices("log-receiver").then(() => {
+					this.hubConnected = true;
+					this.status("info", "Hub reconnected — log forwarding resumed");
+					this.flushOutbound();
+				}).catch(() => {});
+			}
+		});
+	}
+	write(entry) {
+		if (this.hubConnected && this.broker) {
+			this.forward(entry);
+			return;
+		}
+		this.bufferOutbound(entry);
+		const line = require_formatter.formatLogLine(entry, { colorize: true });
+		if (entry.level === "error") console.error(line);
+		else if (entry.level === "warn") console.warn(line);
+		else console.log(line);
+	}
+	async query(_filter) {
+		return [];
+	}
+	async shutdown() {
+		this.hubConnected = false;
+		this.broker = null;
+		this.outboundBuffer.length = 0;
+	}
+	bufferOutbound(entry) {
+		this.outboundBuffer.push(entry);
+		if (this.outboundBuffer.length > DEFAULT_OUTBOUND_BUFFER_SIZE) this.outboundBuffer.splice(0, this.outboundBuffer.length - DEFAULT_OUTBOUND_BUFFER_SIZE);
+	}
+	flushOutbound() {
+		if (!this.broker || !this.hubConnected) return;
+		const pending = this.outboundBuffer.splice(0, this.outboundBuffer.length);
+		for (const entry of pending) this.forward(entry);
+	}
+	forward(entry) {
+		if (!this.broker) return;
+		this.broker.call("log-receiver.ingest", {
+			level: entry.level,
+			message: entry.message,
+			addonId: entry.tags?.addonId ?? "agent",
+			nodeId: entry.tags?.nodeId ?? this.broker.nodeID,
+			...entry.scope !== void 0 ? { scope: entry.scope } : {},
+			...entry.tags ? { tags: entry.tags } : {},
+			...entry.meta ? { meta: entry.meta } : {}
+		}).catch(() => {});
+	}
+};
+//#endregion
+//#region src/builtins/hub-forwarder/hub-forwarder.addon.ts
+/**
+* Agent-only addon that provides the `log-destination` capability.
+* Writes all logs to the console and forwards to the hub via Moleculer when
+* reachable. The broker is read from `ctx.kernel.cluster?.broker`; outbound
+* log replay on hub-connect is handled internally by the destination.
+*/
+var HubForwarderAddon = class extends _camstack_types.BaseAddon {
+	destination = null;
+	constructor() {
+		super({});
+	}
+	async onInitialize() {
+		this.destination = new HubForwarderDestination();
+		await this.destination.initialize();
+		this.destination.setStatusLogger(this.ctx.logger);
+		const broker = this.ctx.kernel.cluster?.broker;
+		if (broker) this.destination.connectBroker(broker);
+		else this.ctx.logger.warn("cluster.broker not available — hub forwarding disabled, console only");
+		this.ctx.logger.info("Hub forwarder log destination registered");
+		return [{
+			capability: _camstack_types.logDestinationCapability,
+			provider: this.destination
+		}];
+	}
+	getDestination() {
+		return this.destination;
+	}
+	async onShutdown() {
+		await this.destination?.shutdown();
+		this.destination = null;
+	}
+};
+//#endregion
+exports.HubForwarderAddon = HubForwarderAddon;
+exports.HubForwarderAddon$1 = HubForwarderAddon;
+exports.HubForwarderDestination = HubForwarderDestination;
+exports.HubForwarderDestination$1 = HubForwarderDestination;
+exports.default = HubForwarderAddon;

package/dist/builtins/hub-forwarder/index.mjs

@@ -0,0 +1,145 @@
+import { t as formatLogLine } from "../../formatter-B7qW8bPJ.mjs";
+import { BaseAddon, logDestinationCapability } from "@camstack/types";
+//#region src/builtins/hub-forwarder/hub-forwarder-destination.ts
+var DEFAULT_OUTBOUND_BUFFER_SIZE = 500;
+/**
+* Log destination for agent mode.
+*
+* - Writes to console ONLY when hub is not yet reachable (cold-start
+*   fallback). Forked-worker agents share stdout with their parent
+*   hub, so logging to local console AND forwarding to hub's
+*   `log-receiver` would print the entry twice on the hub terminal.
+*   Once the hub is discovered, local console output stops and the
+*   hub's own ConsoleDestination owns the render.
+* - When a Moleculer broker is connected and the hub node is reachable,
+*   forwards every log entry to the hub via `log-receiver.ingest`.
+* - Entries written before the hub is reachable are buffered internally
+*   (ring-buffered to `DEFAULT_OUTBOUND_BUFFER_SIZE`) and flushed on connect,
+*   so boot-time logs still reach the hub without any external replay trigger.
+*/
+var HubForwarderDestination = class {
+	broker = null;
+	hubConnected = false;
+	outboundBuffer = [];
+	statusLogger = null;
+	async initialize() {}
+	/**
+	* Provide a logger for the destination's own status messages
+	* (discovery, disconnect, reconnect). Routed through the agent's
+	* LogManager but never through this same destination — the owning
+	* addon must hand in a logger that does NOT route back here, or
+	* status writes will recurse.
+	*/
+	setStatusLogger(logger) {
+		this.statusLogger = logger;
+	}
+	status(level, msg) {
+		if (this.statusLogger) {
+			if (level === "warn") this.statusLogger.warn(msg);
+			else this.statusLogger.info(msg);
+			return;
+		}
+		if (level === "warn") console.warn(`[hub-forwarder] ${msg}`);
+		else console.log(`[hub-forwarder] ${msg}`);
+	}
+	/**
+	* Attach the Moleculer broker so hub forwarding can start.
+	* Called by the owning addon from `onInitialize(ctx)` with
+	* `ctx.kernel.cluster?.broker`.
+	*/
+	connectBroker(broker) {
+		this.broker = broker;
+		broker.waitForServices("log-receiver").then(() => {
+			this.hubConnected = true;
+			this.status("info", "log-receiver discovered — log forwarding active");
+			this.flushOutbound();
+		}).catch(() => {});
+		broker.localBus.on("$node.disconnected", ({ node }) => {
+			if (node.id === "hub") {
+				this.hubConnected = false;
+				this.status("info", "Hub disconnected — log forwarding paused");
+				broker.waitForServices("log-receiver").then(() => {
+					this.hubConnected = true;
+					this.status("info", "Hub reconnected — log forwarding resumed");
+					this.flushOutbound();
+				}).catch(() => {});
+			}
+		});
+	}
+	write(entry) {
+		if (this.hubConnected && this.broker) {
+			this.forward(entry);
+			return;
+		}
+		this.bufferOutbound(entry);
+		const line = formatLogLine(entry, { colorize: true });
+		if (entry.level === "error") console.error(line);
+		else if (entry.level === "warn") console.warn(line);
+		else console.log(line);
+	}
+	async query(_filter) {
+		return [];
+	}
+	async shutdown() {
+		this.hubConnected = false;
+		this.broker = null;
+		this.outboundBuffer.length = 0;
+	}
+	bufferOutbound(entry) {
+		this.outboundBuffer.push(entry);
+		if (this.outboundBuffer.length > DEFAULT_OUTBOUND_BUFFER_SIZE) this.outboundBuffer.splice(0, this.outboundBuffer.length - DEFAULT_OUTBOUND_BUFFER_SIZE);
+	}
+	flushOutbound() {
+		if (!this.broker || !this.hubConnected) return;
+		const pending = this.outboundBuffer.splice(0, this.outboundBuffer.length);
+		for (const entry of pending) this.forward(entry);
+	}
+	forward(entry) {
+		if (!this.broker) return;
+		this.broker.call("log-receiver.ingest", {
+			level: entry.level,
+			message: entry.message,
+			addonId: entry.tags?.addonId ?? "agent",
+			nodeId: entry.tags?.nodeId ?? this.broker.nodeID,
+			...entry.scope !== void 0 ? { scope: entry.scope } : {},
+			...entry.tags ? { tags: entry.tags } : {},
+			...entry.meta ? { meta: entry.meta } : {}
+		}).catch(() => {});
+	}
+};
+//#endregion
+//#region src/builtins/hub-forwarder/hub-forwarder.addon.ts
+/**
+* Agent-only addon that provides the `log-destination` capability.
+* Writes all logs to the console and forwards to the hub via Moleculer when
+* reachable. The broker is read from `ctx.kernel.cluster?.broker`; outbound
+* log replay on hub-connect is handled internally by the destination.
+*/
+var HubForwarderAddon = class extends BaseAddon {
+	destination = null;
+	constructor() {
+		super({});
+	}
+	async onInitialize() {
+		this.destination = new HubForwarderDestination();
+		await this.destination.initialize();
+		this.destination.setStatusLogger(this.ctx.logger);
+		const broker = this.ctx.kernel.cluster?.broker;
+		if (broker) this.destination.connectBroker(broker);
+		else this.ctx.logger.warn("cluster.broker not available — hub forwarding disabled, console only");
+		this.ctx.logger.info("Hub forwarder log destination registered");
+		return [{
+			capability: logDestinationCapability,
+			provider: this.destination
+		}];
+	}
+	getDestination() {
+		return this.destination;
+	}
+	async onShutdown() {
+		await this.destination?.shutdown();
+		this.destination = null;
+	}
+};
+//#endregion
+export { HubForwarderAddon, HubForwarderAddon as default, HubForwarderDestination };

package/dist/builtins/local-auth/auth-schema.d.ts

@@ -0,0 +1,26 @@
+import { SettingsStoreClient } from '@camstack/types';
+export declare const USERS_COLLECTION = "users";
+export declare const API_KEYS_COLLECTION = "api_keys";
+export declare const SCOPED_TOKENS_COLLECTION = "scoped_tokens";
+export declare const OAUTH_SESSIONS_COLLECTION = "oauth_sessions";
+/**
+ * TOTP enrollment table — split off from `users` to avoid the
+ * destructive drop-+-recreate migration `ensureTable` performs when a
+ * new column is added to a typed schema (see `sqlite-settings-backend.ts`).
+ *
+ * Lifecycle:
+ *   - Setup: row inserted with `confirmedAt = null` and a fresh secret.
+ *   - Confirm: a valid code from the secret flips `confirmedAt` to now().
+ *   - Disable: the row is deleted (next setup starts fresh).
+ *
+ * "Enabled" means `confirmedAt != null`. A half-enrolled row (`confirmedAt
+ * = null`) is INACTIVE — `verifyTotp` returns false until confirmation.
+ */
+export declare const USER_TOTP_COLLECTION = "user_totp";
+/**
+ * Declare every auth collection with the typed schema. Called by
+ * `LocalAuthAddon.onInitialize` before constructing the per-collection
+ * managers. Idempotent — `declareCollection` is a no-op when the
+ * collection has already been declared (same shape).
+ */
+export declare function declareAuthSchema(store: SettingsStoreClient): Promise<void>;

package/dist/builtins/local-auth/index.d.ts

@@ -0,0 +1 @@
+export { LocalAuthAddon } from './local-auth.addon.js';

package/dist/builtins/local-auth/index.js

@@ -0,0 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../chunk-Cek0wNdY.js");
+const require_builtins_local_auth_local_auth_addon = require("./local-auth.addon.js");
+exports.LocalAuthAddon = require_builtins_local_auth_local_auth_addon.LocalAuthAddon;

package/dist/builtins/local-auth/index.mjs

@@ -0,0 +1,2 @@
+import { LocalAuthAddon } from "./local-auth.addon.mjs";
+export { LocalAuthAddon };

package/dist/builtins/local-auth/local-auth.addon.d.ts

@@ -0,0 +1,18 @@
+import { ProviderRegistration, BaseAddon } from '@camstack/types';
+interface LocalAuthConfig {
+    jwtSecret?: string;
+    adminUsername?: string;
+    adminPassword?: string;
+}
+export declare class LocalAuthAddon extends BaseAddon<LocalAuthConfig> {
+    private authManager;
+    private userManager;
+    private apiKeyManager;
+    private scopedTokenManager;
+    private oauthSessionManager;
+    private totpManager;
+    constructor();
+    protected onInitialize(): Promise<ProviderRegistration[]>;
+    protected onShutdown(): Promise<void>;
+}
+export default LocalAuthAddon;