@camstack/server 0.2.2 → 1.0.1

package/src/api/auth-whoami.ts

@@ -1,101 +0,0 @@
-/**
- * `GET /api/auth/whoami` — validate the caller's token and surface the
- * canonical identity + scope summary the server sees.
- *
- * Designed for the CLI `camstack whoami` command, which used to trust
- * the local cache blindly. Hitting this endpoint catches:
- *   • revocation (token was deleted server-side after the local cache)
- *   • expiry
- *   • orphan-cleanup (e.g. owner deleted, see local-auth boot migration)
- *
- * Accepts both JWT and `cst_*` scoped tokens. Returns 401 on auth fail;
- * 200 with the resolved identity otherwise. We intentionally do NOT
- * expose `tokenHash` or the raw token — only `tokenPrefix` + scopes for
- * the client to confirm the cached blob matches what the server has.
- */
-import type { FastifyInstance } from 'fastify'
-import type { AuthService } from '../core/auth/auth.service'
-import type { AddonRegistryService } from '../core/addon/addon-registry.service'
-
-interface ScopedTokenLike {
-  readonly id: string
-  readonly userId: string
-  readonly name: string
-  readonly tokenPrefix: string
-  readonly scopes: readonly { type: string; target: string }[]
-  readonly expiresAt?: number | null
-  readonly lastUsedAt?: number | null
-  readonly createdAt: number
-}
-interface UserManagementLike {
-  validateScopedToken(input: { token: string }): Promise<ScopedTokenLike | null>
-}
-
-interface WhoamiOk {
-  readonly ok: true
-  readonly kind: 'jwt' | 'scoped'
-  readonly userId: string
-  readonly username: string
-  readonly isAdmin?: boolean
-  readonly tokenPrefix?: string
-  readonly scopes?: readonly { type: string; target: string }[]
-  readonly expiresAt?: number | null
-  readonly createdAt?: number
-}
-
-export async function registerAuthWhoamiRoute(
-  fastify: FastifyInstance,
-  authService: AuthService,
-  addonRegistry: AddonRegistryService,
-): Promise<void> {
-  fastify.get('/api/auth/whoami', async (request, reply) => {
-    const authHeader = request.headers.authorization
-    if (!authHeader) {
-      return reply.status(401).send({ ok: false, error: 'No Authorization header' })
-    }
-    const token = authHeader.replace('Bearer ', '')
-
-    // JWT fast path — same logic as addon-upload auth chain.
-    try {
-      const payload = authService.verifyToken(token)
-      const ok: WhoamiOk = {
-        ok: true,
-        kind: 'jwt',
-        userId: payload.userId ?? payload.keyId ?? 'unknown',
-        username: payload.username ?? 'unknown',
-        isAdmin: payload.isAdmin,
-      }
-      return reply.send(ok)
-    } catch {
-      // Not a JWT — try scoped token via cap registry.
-    }
-
-    try {
-      const capRegistry = addonRegistry.getCapabilityRegistry()
-      const userMgmt = capRegistry.getSingleton('user-management') as UserManagementLike | undefined
-      if (!userMgmt) {
-        return reply.status(503).send({ ok: false, error: 'user-management cap not mounted' })
-      }
-      const record = await userMgmt.validateScopedToken({ token })
-      if (!record) {
-        return reply
-          .status(401)
-          .send({ ok: false, error: 'Token not recognised (revoked, expired, or never issued)' })
-      }
-      const ok: WhoamiOk = {
-        ok: true,
-        kind: 'scoped',
-        userId: record.userId,
-        username: record.userId,
-        tokenPrefix: record.tokenPrefix,
-        scopes: record.scopes,
-        expiresAt: record.expiresAt ?? null,
-        createdAt: record.createdAt,
-      }
-      return reply.send(ok)
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err)
-      return reply.status(500).send({ ok: false, error: `Validation failed: ${msg}` })
-    }
-  })
-}

package/src/api/bridge-addons.router.ts

@@ -1,122 +0,0 @@
-import { z } from 'zod'
-import { TRPCError } from '@trpc/server'
-import { protectedProcedure, adminProcedure, trpcRouter } from './trpc/trpc.middleware'
-import type { AddonBridgeService } from '../core/addon-bridge/addon-bridge.service'
-import type { AddonSearchService } from '../core/addon/addon-search.service'
-import type { AddonRegistryService } from '../core/addon/addon-registry.service'
-import type { ToastService } from '@camstack/core'
-
-export function createBridgeAddonsRouter(
-  bridge: AddonBridgeService,
-  addonSearch: AddonSearchService,
-  addonRegistry?: AddonRegistryService,
-  toastService?: ToastService,
-) {
-  return trpcRouter({
-    /** List all addon packages installed in the addons directory */
-    listPackages: protectedProcedure.query(() => {
-      const installer = bridge.getInstaller()
-      if (!installer) return []
-      return installer.listInstalled()
-    }),
-
-    /** List all available addons across all loaded packages */
-    listAddons: 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: adminProcedure
-      .input(z.object({ packageName: z.string(), version: z.string().optional() }))
-      .mutation(async ({ input }) => {
-        const installer = bridge.getInstaller()
-        if (!installer) {
-          throw new 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: adminProcedure
-      .input(z.object({ packageName: 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 TRPCError({
-            code: 'FORBIDDEN',
-            message: `Package ${input.packageName} is required and cannot be uninstalled`,
-          })
-        }
-
-        const installer = bridge.getInstaller()
-        if (!installer) {
-          throw new 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: adminProcedure.mutation(async () => {
-      await bridge.reloadPackages()
-      return { success: true, message: 'Addon packages reloaded' }
-    }),
-
-    /** Search npm for available CamStack addons */
-    searchAvailable: protectedProcedure
-      .input(z.object({ query: 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/src/api/capabilities.router.ts

@@ -1,265 +0,0 @@
-import { z } from 'zod'
-import { TRPCError } from '@trpc/server'
-import { adminProcedure, trpcRouter } from './trpc/trpc.middleware'
-import type { AddonRegistryService } from '../core/addon/addon-registry.service'
-import type { ConfigService } from '../core/config/config.service'
-import type { LoggingService } from '../core/logging/logging.service'
-import { isInfraCapability } from '@camstack/kernel'
-import { collectionPreferenceKey, persistCollectionDisabled } from './core/collection-preference'
-
-// ─── Zod Schemas ───────────────────────────────────────────────────────────
-
-const setPreferenceInput = z.discriminatedUnion('mode', [
-  z.object({
-    mode: z.literal('singleton'),
-    capability: z.string(),
-    addonId: z.string(),
-  }),
-  z.object({
-    mode: z.literal('collection'),
-    capability: z.string(),
-    addonId: z.string(),
-    enabled: z.boolean(),
-  }),
-])
-
-// ─── Router ────────────────────────────────────────────────────────────────
-
-export function createCapabilitiesRouter(
-  addonRegistry: AddonRegistryService,
-  configService: ConfigService,
-  loggingService: LoggingService,
-) {
-  const logger = loggingService.createLogger('CapabilitiesRouter')
-
-  /** Build enriched provider details from addon metadata */
-  function getProviderDetails(addonIds: readonly string[]) {
-    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 trpcRouter({
-    // ─── List all capabilities with enriched metadata ──────────────────
-
-    list: adminProcedure.query(() => {
-      const registry = addonRegistry.getCapabilityRegistry()
-      const caps = registry.listCapabilities()
-      return caps.map((cap) => ({
-        ...cap,
-        providerDetails: getProviderDetails(cap.providers),
-        isInfra: isInfraCapability(cap.name),
-      }))
-    }),
-
-    // ─── Get current preference for a capability ──────────────────────
-
-    getPreference: adminProcedure.input(z.object({ capability: 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<string>(`capabilities.singleton.${input.capability}`)
-        return {
-          capability: input.capability,
-          mode: mode as 'singleton',
-          preference: addonId ? { addonId } : null,
-        }
-      }
-
-      // collection
-      const raw = configService.get<string>(collectionPreferenceKey(input.capability))
-      let disabled: string[] = []
-      if (raw) {
-        try {
-          const parsed = JSON.parse(raw) as { disabled?: string[] }
-          disabled = Array.isArray(parsed.disabled) ? parsed.disabled : []
-        } catch {
-          /* ignore malformed */
-        }
-      }
-      return {
-        capability: input.capability,
-        mode: mode as 'collection',
-        preference: { disabled },
-      }
-    }),
-
-    // ─── Set preference (singleton switch or collection toggle) ───────
-
-    setPreference: 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 TRPCError({ code: 'NOT_FOUND', message: `Unknown capability: ${capability}` })
-        if (cap.mode !== 'singleton')
-          throw new TRPCError({
-            code: 'BAD_REQUEST',
-            message: `"${capability}" is not a singleton`,
-          })
-        if (!cap.providers.includes(addonId)) {
-          throw new TRPCError({
-            code: 'BAD_REQUEST',
-            message: `Provider "${addonId}" is not registered for "${capability}"`,
-          })
-        }
-
-        const requiresRestart = 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 TRPCError({ code: 'NOT_FOUND', message: `Unknown capability: ${capability}` })
-      if (cap.mode !== 'collection')
-        throw new TRPCError({ code: 'BAD_REQUEST', message: `"${capability}" is not a collection` })
-      if (!cap.providers.includes(addonId)) {
-        throw new 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)
-      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: adminProcedure
-      .input(z.object({ capability: z.string() }))
-      .mutation(({ input }) => {
-        const registry = addonRegistry.getCapabilityRegistry()
-        const mode = registry.getMode(input.capability)
-        if (!mode)
-          throw new 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: adminProcedure.query(() => {
-      const registry = addonRegistry.getCapabilityRegistry()
-      return registry.listCapabilities()
-    }),
-
-    setDeviceCapability: adminProcedure
-      .input(z.object({ deviceId: z.string(), capability: z.string(), addonId: 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: adminProcedure
-      .input(z.object({ deviceId: z.string(), capability: 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: adminProcedure
-      .input(z.object({ deviceId: z.string() }))
-      .output(z.record(z.string(), z.string()))
-      .query(({ input }): Record<string, string> => {
-        const registry = addonRegistry.getCapabilityRegistry()
-        const overrides = registry.getDeviceOverrides(input.deviceId)
-        return Object.fromEntries(overrides) as Record<string, string>
-      }),
-
-    setDeviceCollectionFilter: adminProcedure
-      .input(
-        z.object({ deviceId: z.string(), capability: z.string(), addonIds: z.array(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: adminProcedure
-      .input(z.object({ deviceId: z.string(), capability: 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 },
-        })
-      }),
-  })
-}