@camstack/server 1.0.0 → 1.0.1

package/dist/api/bridge-addons.router.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBridgeAddonsRouter = createBridgeAddonsRouter;
+const zod_1 = require("zod");
+const server_1 = require("@trpc/server");
+const trpc_middleware_1 = require("./trpc/trpc.middleware");
+function createBridgeAddonsRouter(bridge, addonSearch, addonRegistry, toastService) {
+    return (0, trpc_middleware_1.trpcRouter)({
+        /** List all addon packages installed in the addons directory */
+        listPackages: trpc_middleware_1.protectedProcedure.query(() => {
+            const installer = bridge.getInstaller();
+            if (!installer)
+                return [];
+            return installer.listInstalled();
+        }),
+        /** List all available addons across all loaded packages */
+        listAddons: trpc_middleware_1.protectedProcedure.query(() => {
+            return bridge.listAvailableAddons().map((id) => {
+                const addon = bridge.getLoader().getAddon(id);
+                return {
+                    id,
+                    packageName: addon?.packageName ?? 'unknown',
+                    slot: addon?.declaration.slot ?? null,
+                };
+            });
+        }),
+        /** Install a community addon package from npm */
+        installPackage: trpc_middleware_1.adminProcedure
+            .input(zod_1.z.object({ packageName: zod_1.z.string(), version: zod_1.z.string().optional() }))
+            .mutation(async ({ input }) => {
+            const installer = bridge.getInstaller();
+            if (!installer) {
+                throw new server_1.TRPCError({
+                    code: 'PRECONDITION_FAILED',
+                    message: 'Addon installer not available — bridge may have failed to initialize',
+                });
+            }
+            await installer.install(input.packageName, input.version);
+            await bridge.reloadPackages();
+            const result = addonRegistry
+                ? await addonRegistry.loadNewAddons()
+                : { loaded: [], failed: [] };
+            toastService?.broadcast({
+                title: 'Addon Installed',
+                message: `${input.packageName} installed successfully${result.loaded.length ? ` (${result.loaded.join(', ')})` : ''}`,
+                severity: result.failed.length ? 'warning' : 'info',
+            });
+            return { success: true, loaded: result.loaded, failed: result.failed };
+        }),
+        /** Uninstall a community addon package */
+        uninstallPackage: trpc_middleware_1.adminProcedure
+            .input(zod_1.z.object({ packageName: zod_1.z.string() }))
+            .mutation(async ({ input }) => {
+            // Server-side guard: prevent uninstalling required packages.
+            // After Phase D bundle merge, the pipeline-related packages
+            // (stream-broker, detection-pipeline, motion-wasm, decoders,
+            // audio) all live in @camstack/addon-pipeline.
+            const REQUIRED = new Set([
+                '@camstack/core',
+                '@camstack/addon-pipeline',
+                '@camstack/addon-pipeline-orchestrator',
+                '@camstack/addon-post-analysis',
+                '@camstack/addon-admin-ui',
+            ]);
+            if (REQUIRED.has(input.packageName)) {
+                throw new server_1.TRPCError({
+                    code: 'FORBIDDEN',
+                    message: `Package ${input.packageName} is required and cannot be uninstalled`,
+                });
+            }
+            const installer = bridge.getInstaller();
+            if (!installer) {
+                throw new server_1.TRPCError({
+                    code: 'PRECONDITION_FAILED',
+                    message: 'Addon installer not available — bridge may have failed to initialize',
+                });
+            }
+            await installer.uninstall(input.packageName);
+            await bridge.reloadPackages();
+            if (addonRegistry)
+                await addonRegistry.loadNewAddons();
+            toastService?.broadcast({
+                title: 'Addon Uninstalled',
+                message: `${input.packageName} has been removed`,
+                severity: 'info',
+            });
+            return { success: true };
+        }),
+        /** Force reload all addon packages (re-scan directories, re-import modules) */
+        reloadPackages: trpc_middleware_1.adminProcedure.mutation(async () => {
+            await bridge.reloadPackages();
+            return { success: true, message: 'Addon packages reloaded' };
+        }),
+        /** Search npm for available CamStack addons */
+        searchAvailable: trpc_middleware_1.protectedProcedure
+            .input(zod_1.z.object({ query: zod_1.z.string().optional() }).optional())
+            .query(async ({ input }) => {
+            const results = await addonSearch.searchAddons(input?.query);
+            // Enrich with install status from locally installed packages
+            const installed = bridge.getInstaller()?.listInstalled() ?? [];
+            const installedMap = new Map(installed.map((p) => [p.name, p.version]));
+            return results.map((r) => ({
+                ...r,
+                installed: installedMap.has(r.name),
+                installedVersion: installedMap.get(r.name),
+            }));
+        }),
+    });
+}

package/dist/api/capabilities.router.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCapabilitiesRouter = createCapabilitiesRouter;
+const zod_1 = require("zod");
+const server_1 = require("@trpc/server");
+const trpc_middleware_1 = require("./trpc/trpc.middleware");
+const kernel_1 = require("@camstack/kernel");
+const collection_preference_1 = require("./core/collection-preference");
+// ─── Zod Schemas ───────────────────────────────────────────────────────────
+const setPreferenceInput = zod_1.z.discriminatedUnion('mode', [
+    zod_1.z.object({
+        mode: zod_1.z.literal('singleton'),
+        capability: zod_1.z.string(),
+        addonId: zod_1.z.string(),
+    }),
+    zod_1.z.object({
+        mode: zod_1.z.literal('collection'),
+        capability: zod_1.z.string(),
+        addonId: zod_1.z.string(),
+        enabled: zod_1.z.boolean(),
+    }),
+]);
+// ─── Router ────────────────────────────────────────────────────────────────
+function createCapabilitiesRouter(addonRegistry, configService, loggingService) {
+    const logger = loggingService.createLogger('CapabilitiesRouter');
+    /** Build enriched provider details from addon metadata */
+    function getProviderDetails(addonIds) {
+        const allAddons = addonRegistry.listAllAddons();
+        return addonIds.map((addonId) => {
+            const addon = allAddons.find((a) => a.manifest.id === addonId);
+            return {
+                addonId,
+                displayName: addon?.manifest.name ?? addonId,
+                packageName: addon?.manifest.packageName ?? addonId,
+            };
+        });
+    }
+    return (0, trpc_middleware_1.trpcRouter)({
+        // ─── List all capabilities with enriched metadata ──────────────────
+        list: trpc_middleware_1.adminProcedure.query(() => {
+            const registry = addonRegistry.getCapabilityRegistry();
+            const caps = registry.listCapabilities();
+            return caps.map((cap) => ({
+                ...cap,
+                providerDetails: getProviderDetails(cap.providers),
+                isInfra: (0, kernel_1.isInfraCapability)(cap.name),
+            }));
+        }),
+        // ─── Get current preference for a capability ──────────────────────
+        getPreference: trpc_middleware_1.adminProcedure.input(zod_1.z.object({ capability: zod_1.z.string() })).query(({ input }) => {
+            const registry = addonRegistry.getCapabilityRegistry();
+            const mode = registry.getMode(input.capability);
+            if (!mode)
+                return null;
+            if (mode === 'singleton') {
+                const addonId = configService.get(`capabilities.singleton.${input.capability}`);
+                return {
+                    capability: input.capability,
+                    mode: mode,
+                    preference: addonId ? { addonId } : null,
+                };
+            }
+            // collection
+            const raw = configService.get((0, collection_preference_1.collectionPreferenceKey)(input.capability));
+            let disabled = [];
+            if (raw) {
+                try {
+                    const parsed = JSON.parse(raw);
+                    disabled = Array.isArray(parsed.disabled) ? parsed.disabled : [];
+                }
+                catch {
+                    /* ignore malformed */
+                }
+            }
+            return {
+                capability: input.capability,
+                mode: mode,
+                preference: { disabled },
+            };
+        }),
+        // ─── Set preference (singleton switch or collection toggle) ───────
+        setPreference: trpc_middleware_1.adminProcedure.input(setPreferenceInput).mutation(async ({ input }) => {
+            const registry = addonRegistry.getCapabilityRegistry();
+            if (input.mode === 'singleton') {
+                const { capability, addonId } = input;
+                const caps = registry.listCapabilities();
+                const cap = caps.find((c) => c.name === capability);
+                if (!cap)
+                    throw new server_1.TRPCError({ code: 'NOT_FOUND', message: `Unknown capability: ${capability}` });
+                if (cap.mode !== 'singleton')
+                    throw new server_1.TRPCError({
+                        code: 'BAD_REQUEST',
+                        message: `"${capability}" is not a singleton`,
+                    });
+                if (!cap.providers.includes(addonId)) {
+                    throw new server_1.TRPCError({
+                        code: 'BAD_REQUEST',
+                        message: `Provider "${addonId}" is not registered for "${capability}"`,
+                    });
+                }
+                const requiresRestart = (0, kernel_1.isInfraCapability)(capability);
+                if (!requiresRestart) {
+                    // Hot-swap at runtime
+                    await registry.setActiveSingleton(capability, addonId);
+                }
+                // Persist preference
+                configService.set(`capabilities.singleton.${capability}`, addonId);
+                logger.info('Singleton preference set', {
+                    tags: { addonId },
+                    meta: { capability, requiresRestart },
+                });
+                return { success: true, requiresRestart };
+            }
+            // collection toggle
+            const { capability, addonId, enabled } = input;
+            const caps = registry.listCapabilities();
+            const cap = caps.find((c) => c.name === capability);
+            if (!cap)
+                throw new server_1.TRPCError({ code: 'NOT_FOUND', message: `Unknown capability: ${capability}` });
+            if (cap.mode !== 'collection')
+                throw new server_1.TRPCError({ code: 'BAD_REQUEST', message: `"${capability}" is not a collection` });
+            if (!cap.providers.includes(addonId)) {
+                throw new server_1.TRPCError({
+                    code: 'BAD_REQUEST',
+                    message: `Provider "${addonId}" is not registered for "${capability}"`,
+                });
+            }
+            if (enabled) {
+                registry.enableCollectionProvider(capability, addonId);
+            }
+            else {
+                registry.disableCollectionProvider(capability, addonId);
+            }
+            // Persist disabled list via the shared canonical writer.
+            const updatedCap = registry.listCapabilities().find((c) => c.name === capability);
+            (0, collection_preference_1.persistCollectionDisabled)(configService, capability, updatedCap?.disabledProviders ?? []);
+            logger.info('Collection provider toggled', {
+                tags: { addonId },
+                meta: { capability, enabled },
+            });
+            return { success: true, requiresRestart: false };
+        }),
+        // ─── Reset preference to default ──────────────────────────────────
+        resetPreference: trpc_middleware_1.adminProcedure
+            .input(zod_1.z.object({ capability: zod_1.z.string() }))
+            .mutation(({ input }) => {
+            const registry = addonRegistry.getCapabilityRegistry();
+            const mode = registry.getMode(input.capability);
+            if (!mode)
+                throw new server_1.TRPCError({
+                    code: 'NOT_FOUND',
+                    message: `Unknown capability: ${input.capability}`,
+                });
+            if (mode === 'singleton') {
+                configService.set(`capabilities.singleton.${input.capability}`, null);
+                logger.info('Singleton preference reset (takes effect on restart)', {
+                    meta: { capability: input.capability },
+                });
+                return { success: true, requiresRestart: true };
+            }
+            // collection: re-enable all disabled providers
+            const caps = registry.listCapabilities();
+            const cap = caps.find((c) => c.name === input.capability);
+            if (cap) {
+                for (const addonId of cap.disabledProviders) {
+                    registry.enableCollectionProvider(input.capability, addonId);
+                }
+            }
+            configService.set(`capabilities.collection.${input.capability}`, null);
+            logger.info('Collection preference reset (all providers re-enabled)', {
+                meta: { capability: input.capability },
+            });
+            return { success: true, requiresRestart: false };
+        }),
+        // ─── Per-device overrides (existing, unchanged) ───────────────────
+        listCapabilities: trpc_middleware_1.adminProcedure.query(() => {
+            const registry = addonRegistry.getCapabilityRegistry();
+            return registry.listCapabilities();
+        }),
+        setDeviceCapability: trpc_middleware_1.adminProcedure
+            .input(zod_1.z.object({ deviceId: zod_1.z.string(), capability: zod_1.z.string(), addonId: zod_1.z.string() }))
+            .mutation(({ input }) => {
+            const registry = addonRegistry.getCapabilityRegistry();
+            registry.setDeviceOverride(input.deviceId, input.capability, input.addonId);
+            logger.info('Device capability override set', {
+                tags: { deviceId: Number(input.deviceId), addonId: input.addonId },
+                meta: { capability: input.capability },
+            });
+        }),
+        clearDeviceCapability: trpc_middleware_1.adminProcedure
+            .input(zod_1.z.object({ deviceId: zod_1.z.string(), capability: zod_1.z.string() }))
+            .mutation(({ input }) => {
+            const registry = addonRegistry.getCapabilityRegistry();
+            registry.clearDeviceOverride(input.deviceId, input.capability);
+            logger.info('Device capability override cleared', {
+                tags: { deviceId: Number(input.deviceId) },
+                meta: { capability: input.capability },
+            });
+        }),
+        getDeviceCapabilities: trpc_middleware_1.adminProcedure
+            .input(zod_1.z.object({ deviceId: zod_1.z.string() }))
+            .output(zod_1.z.record(zod_1.z.string(), zod_1.z.string()))
+            .query(({ input }) => {
+            const registry = addonRegistry.getCapabilityRegistry();
+            const overrides = registry.getDeviceOverrides(input.deviceId);
+            return Object.fromEntries(overrides);
+        }),
+        setDeviceCollectionFilter: trpc_middleware_1.adminProcedure
+            .input(zod_1.z.object({ deviceId: zod_1.z.string(), capability: zod_1.z.string(), addonIds: zod_1.z.array(zod_1.z.string()) }))
+            .mutation(({ input }) => {
+            const registry = addonRegistry.getCapabilityRegistry();
+            registry.setDeviceCollectionFilter(input.deviceId, input.capability, input.addonIds);
+            logger.info('Device collection filter set', {
+                tags: { deviceId: Number(input.deviceId) },
+                meta: { capability: input.capability, addonIds: input.addonIds },
+            });
+        }),
+        clearDeviceCollectionFilter: trpc_middleware_1.adminProcedure
+            .input(zod_1.z.object({ deviceId: zod_1.z.string(), capability: zod_1.z.string() }))
+            .mutation(({ input }) => {
+            const registry = addonRegistry.getCapabilityRegistry();
+            registry.clearDeviceCollectionFilter(input.deviceId, input.capability);
+            logger.info('Device collection filter cleared', {
+                tags: { deviceId: Number(input.deviceId) },
+                meta: { capability: input.capability },
+            });
+        }),
+    });
+}

package/dist/api/core/addon-settings.router.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAddonSettingsRouter = createAddonSettingsRouter;
+/**
+ * Addon settings router — raw DB proxy for the common settings API.
+ *
+ * Exposes four protected procedures consumed by:
+ *   1. Forked addons (via the tRPC WSS client in `WorkerBootstrapService`)
+ *      to read/write their 3-level settings chain from the worker process.
+ *   2. Future UI flows that want to inspect/mutate addon settings through
+ *      a single well-typed endpoint.
+ *
+ * The router is deliberately thin — it does NOT perform schema-based
+ * resolver merging (defaults → global → per-device). That happens on the
+ * consumer side where the addon's `ConfigUISchema` is available:
+ *   - In-process addons: handled by `SettingsResolverService.createView()`
+ *     wired into `AddonContext.settings` during `createAddonContext()`.
+ *   - Forked addons: handled by the `AddonSettingsView` constructed inside
+ *     `WorkerBootstrapService`, which has access to the worker's local
+ *     addon schema.
+ *
+ * Introduced in session 5 Sprint 3a (worker-bootstrap cap-aware wiring).
+ */
+const zod_1 = require("zod");
+const trpc_middleware_js_1 = require("../trpc/trpc.middleware.js");
+const AddonSettingsRecordSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.unknown());
+const AddonIdInputSchema = zod_1.z.object({
+    addonId: zod_1.z.string(),
+});
+const AddonDeviceInputSchema = zod_1.z.object({
+    addonId: zod_1.z.string(),
+    deviceId: zod_1.z.string(),
+});
+const UpdateGlobalInputSchema = zod_1.z.object({
+    addonId: zod_1.z.string(),
+    field: zod_1.z.string(),
+    value: zod_1.z.unknown(),
+});
+const UpdateDeviceInputSchema = zod_1.z.object({
+    addonId: zod_1.z.string(),
+    deviceId: zod_1.z.string(),
+    field: zod_1.z.string(),
+    value: zod_1.z.unknown(),
+});
+const SuccessSchema = zod_1.z.object({ success: zod_1.z.literal(true) });
+const ReplaceGlobalInputSchema = zod_1.z.object({
+    addonId: zod_1.z.string(),
+    config: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()),
+});
+function createAddonSettingsRouter(cfg) {
+    return (0, trpc_middleware_js_1.trpcRouter)({
+        /**
+         * Read the addon-global settings record for the given addon.
+         * Returns the raw stored values (no defaults, no device overrides).
+         */
+        getGlobal: trpc_middleware_js_1.protectedProcedure
+            .input(AddonIdInputSchema)
+            .output(AddonSettingsRecordSchema)
+            .query(({ input }) => cfg.getAddonConfig(input.addonId)),
+        /**
+         * Read the per-device override record for the given addon × device.
+         * Returns the raw stored values (schema filtering happens on the
+         * consumer side at merge time).
+         */
+        getDeviceOverrides: trpc_middleware_js_1.protectedProcedure
+            .input(AddonDeviceInputSchema)
+            .output(AddonSettingsRecordSchema)
+            .query(({ input }) => cfg.getAddonDevice(input.addonId, input.deviceId)),
+        /**
+         * Update a single field in the addon-global settings record.
+         * Reads the current record, merges the new value, and writes back
+         * via `setAddonConfig` (bulk replace). Intended for small per-field
+         * writes from addon code; bulk updates should use a dedicated admin
+         * endpoint (not exposed here).
+         */
+        updateGlobal: trpc_middleware_js_1.protectedProcedure
+            .input(UpdateGlobalInputSchema)
+            .output(SuccessSchema)
+            .mutation(({ input }) => {
+            const current = cfg.getAddonConfig(input.addonId);
+            cfg.setAddonConfig(input.addonId, { ...current, [input.field]: input.value });
+            return { success: true };
+        }),
+        /**
+         * Update a single field in the per-device override record for the
+         * given addon × device. Merges with the existing overrides and
+         * writes back via `setAddonDevice`. Scope enforcement (dropping
+         * fields not declared as `scope: 'device'`) is the consumer's
+         * responsibility — we preserve the raw shape at this layer so the
+         * resolver contract remains symmetric with `getDeviceOverrides`.
+         */
+        updateDevice: trpc_middleware_js_1.protectedProcedure
+            .input(UpdateDeviceInputSchema)
+            .output(SuccessSchema)
+            .mutation(({ input }) => {
+            const current = cfg.getAddonDevice(input.addonId, input.deviceId);
+            cfg.setAddonDevice(input.addonId, input.deviceId, {
+                ...current,
+                [input.field]: input.value,
+            });
+            return { success: true };
+        }),
+        /**
+         * Replace the entire addon-global settings record in one call.
+         * Used by forked workers for `context.config.setAll()`. Unlike
+         * `updateGlobal` (single-field merge), this overwrites the full record.
+         * Admin-level write: only workers with valid hub tokens can call this.
+         */
+        replaceGlobal: trpc_middleware_js_1.protectedProcedure
+            .input(ReplaceGlobalInputSchema)
+            .output(SuccessSchema)
+            .mutation(({ input }) => {
+            cfg.setAddonConfig(input.addonId, input.config);
+            return { success: true };
+        }),
+    });
+}

package/dist/api/core/agents.router.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAgentsRouter = createAgentsRouter;
+/**
+ * Agents router — fixed core API (not a capability).
+ *
+ * Thin binding over AgentRegistryService which now delegates to Moleculer
+ * for node discovery and health. Only role-assignment management and
+ * node listing remain; protocol endpoints (register, heartbeat, task
+ * dispatch) are handled natively by the Moleculer service mesh.
+ */
+const zod_1 = require("zod");
+const trpc_middleware_js_1 = require("../trpc/trpc.middleware.js");
+const AgentRoleSchema = zod_1.z.enum(['decoder', 'transcoder', 'detector', 'recorder']);
+function createAgentsRouter(ar, moleculer) {
+    return (0, trpc_middleware_js_1.trpcRouter)({
+        // ── Node listing (replaces listAgents / listConnected) ────────────
+        listNodes: trpc_middleware_js_1.adminProcedure.input(zod_1.z.void()).query(async () => {
+            const items = await ar.listNodes();
+            // Spread to mutable copies: AgentListItem uses readonly arrays; Zod output schema uses mutable.
+            return items.map((a) => ({
+                ...a,
+                info: {
+                    ...a.info,
+                    capabilities: [...a.info.capabilities],
+                },
+                status: {
+                    ...a.status,
+                    fps: { ...a.status.fps },
+                    errors: [...a.status.errors],
+                },
+                subProcesses: [...a.subProcesses],
+            }));
+        }),
+        // ── Capability discovery (via Moleculer service list) ─────────────
+        getAgentCapabilities: trpc_middleware_js_1.adminProcedure.input(zod_1.z.void()).query(async () => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access -- moleculer.broker.call typing chain unresolvable; runtime shape validated by the cast below
+            const services = (await moleculer.broker.call('$node.services', {}));
+            const capSet = new Set();
+            for (const svc of services) {
+                if (svc.name.startsWith('$'))
+                    continue;
+                capSet.add(svc.name);
+            }
+            return [...capSet].toSorted();
+        }),
+        // ── Role assignments ──────────────────────────────────────────────
+        getAssignments: trpc_middleware_js_1.adminProcedure
+            .input(zod_1.z.object({ cameraId: zod_1.z.number().optional() }))
+            .query(({ input }) => ar.getAssignments(input.cameraId)),
+        setAssignment: trpc_middleware_js_1.adminProcedure
+            .input(zod_1.z.object({
+            cameraId: zod_1.z.number(),
+            role: AgentRoleSchema,
+            agentId: zod_1.z.string(),
+            priority: zod_1.z.enum(['primary', 'backup', 'overflow']),
+            rtspUrl: zod_1.z.string().optional(),
+        }))
+            .mutation(({ input }) => ar.setAssignment(input)),
+        removeAssignment: trpc_middleware_js_1.adminProcedure
+            .input(zod_1.z.object({
+            cameraId: zod_1.z.number(),
+            role: AgentRoleSchema,
+        }))
+            .mutation(({ input }) => ar.removeAssignment(input.cameraId, input.role)),
+        activateBackup: trpc_middleware_js_1.adminProcedure
+            .input(zod_1.z.object({
+            cameraId: zod_1.z.number(),
+            role: AgentRoleSchema,
+        }))
+            .mutation(({ input }) => ar.activateBackup(input.cameraId, input.role)),
+    });
+}