@camstack/server 0.1.7 → 0.2.0

package/src/api/trpc/cap-mount-helpers.ts

@@ -64,38 +64,60 @@ export function requireDeviceScoped<K extends keyof CapabilityProviderMap>(
   // a function that, on call, looks up the per-device native and
   // forwards the call. No caching — the lookup is cheap (Map.get) and
   // re-doing it per call lets devices come/go without stale refs.
-  const dispatcher = new Proxy({}, {
-    get(_target, prop: string | symbol) {
-      if (typeof prop !== 'string') return undefined
-      return async (input: { deviceId?: number } & Record<string, unknown>) => {
-        const deviceId = input?.deviceId
-        if (typeof deviceId !== 'number') {
-          throw new TRPCError({
-            code: 'BAD_REQUEST',
-            message: `${String(capName)}.${prop}: input must carry numeric "deviceId"`,
-          })
+  const dispatcher = new Proxy(
+    {},
+    {
+      get(_target, prop: string | symbol) {
+        if (typeof prop !== 'string') return undefined
+        return async (input: { deviceId?: number } & Record<string, unknown>) => {
+          const deviceId = input?.deviceId
+          if (typeof deviceId !== 'number') {
+            throw new TRPCError({
+              code: 'BAD_REQUEST',
+              message: `${String(capName)}.${prop}: input must carry numeric "deviceId"`,
+            })
+          }
+          const native = registry.getNativeProvider<Record<string, (i: unknown) => unknown>>(
+            capName,
+            deviceId,
+          )
+          if (!native) {
+            throw new TRPCError({
+              code: 'PRECONDITION_FAILED',
+              message: `Capability "${String(capName)}" not registered for device ${deviceId}`,
+            })
+          }
+          const fn = native[prop]
+          if (typeof fn !== 'function') {
+            throw new TRPCError({
+              code: 'NOT_IMPLEMENTED',
+              message: `Capability "${String(capName)}" provider for device ${deviceId} does not implement "${prop}"`,
+            })
+          }
+          const result = await fn.call(native, input)
+          // Device-property-wiring overlay (read-time): only `getStatus`, and only
+          // when the device has links for this cap (resolveLinkedStatus returns
+          // null otherwise → base result untouched). One in-process singleton hop.
+          if (prop === 'getStatus') {
+            const deviceManager = registry.getSingleton<{
+              resolveLinkedStatus?: (i: {
+                deviceId: number
+                cap: string
+                baseStatus: unknown
+              }) => Promise<Record<string, unknown> | null>
+            }>('device-manager')
+            const overlaid = await deviceManager?.resolveLinkedStatus?.({
+              deviceId,
+              cap: String(capName),
+              baseStatus: result,
+            })
+            if (overlaid != null) return overlaid
+          }
+          return result
         }
-        const native = registry.getNativeProvider<Record<string, (i: unknown) => unknown>>(
-          capName,
-          deviceId,
-        )
-        if (!native) {
-          throw new TRPCError({
-            code: 'PRECONDITION_FAILED',
-            message: `Capability "${String(capName)}" not registered for device ${deviceId}`,
-          })
-        }
-        const fn = native[prop]
-        if (typeof fn !== 'function') {
-          throw new TRPCError({
-            code: 'NOT_IMPLEMENTED',
-            message: `Capability "${String(capName)}" provider for device ${deviceId} does not implement "${prop}"`,
-          })
-        }
-        return fn.call(native, input)
-      }
+      },
     },
-  })
+  )
   return dispatcher as unknown as CapabilityProviderMap[K]
 }
 
@@ -103,16 +125,16 @@ export function requireDeviceScoped<K extends keyof CapabilityProviderMap>(
 
 /** A key on T whose value is a function with array / promise-array return. */
 type ArrayReturningMethodKey<T> = {
-  [K in keyof T]: T[K] extends (...args: infer _A) => readonly unknown[] | Promise<readonly unknown[]>
+  [K in keyof T]: T[K] extends (
+    ...args: infer _A
+  ) => readonly unknown[] | Promise<readonly unknown[]>
     ? K
     : never
 }[keyof T]
 
 /** A key on T whose value is a function returning boolean / promise-boolean. */
 type BoolReturningMethodKey<T> = {
-  [K in keyof T]: T[K] extends (...args: infer _A) => boolean | Promise<boolean>
-    ? K
-    : never
+  [K in keyof T]: T[K] extends (...args: infer _A) => boolean | Promise<boolean> ? K : never
 }[keyof T]
 
 /**
@@ -120,10 +142,7 @@ type BoolReturningMethodKey<T> = {
  * and concatenates their array results. Useful for contribution-style
  * caps where each provider adds to a shared pool.
  */
-export function concatCollection<
-  T extends object,
-  K extends ArrayReturningMethodKey<T>,
->(
+export function concatCollection<T extends object, K extends ArrayReturningMethodKey<T>>(
   providers: readonly T[],
   method: K,
 ): T[K] extends (...args: infer A) => readonly (infer R)[] | Promise<readonly (infer R)[]>
@@ -147,7 +166,9 @@ export function concatCollection<
   // matches the declared generic conditional return; TypeScript's
   // conditional types can't be narrowed inside a function body, so this
   // boundary assertion is required.
-  return wrapper as T[K] extends (...args: infer A) => readonly (infer R)[] | Promise<readonly (infer R)[]>
+  return wrapper as T[K] extends (
+    ...args: infer A
+  ) => readonly (infer R)[] | Promise<readonly (infer R)[]>
     ? (...args: A) => Promise<readonly R[]>
     : never
 }
@@ -198,10 +219,7 @@ export function firstSupported<
  * Convenience for collection caps that want a "logical OR of probes"
  * (e.g. `supportsDevice` across every snapshot-provider).
  */
-export function anySupports<
-  T extends object,
-  K extends BoolReturningMethodKey<T>,
->(
+export function anySupports<T extends object, K extends BoolReturningMethodKey<T>>(
   providers: readonly T[],
   probe: K,
 ): T[K] extends (...args: infer A) => boolean | Promise<boolean>
@@ -214,7 +232,9 @@ export function anySupports<
       try {
         const result: unknown = await Reflect.apply(member, p, args)
         if (result === true) return true
-      } catch { /* next */ }
+      } catch {
+        /* next */
+      }
     }
     return false
   }

package/src/api/trpc/cap-route-error-formatter.ts

@@ -38,7 +38,12 @@ export interface AugmentedErrorShape extends DefaultErrorShape {
 // ---------------------------------------------------------------------------
 
 /** Known CapRouteError reason values — used as a runtime safety rail. */
-const KNOWN_REASONS = new Set<string>(['no-provider', 'node-offline', 'cap-unknown', 'transport-failed'])
+const KNOWN_REASONS = new Set<string>([
+  'no-provider',
+  'node-offline',
+  'cap-unknown',
+  'transport-failed',
+])
 
 /** Narrows a plain string to the `CapRouteError['reason']` union. */
 function isCapRouteReason(r: string): r is CapRouteError['reason'] {
@@ -101,14 +106,17 @@ function extractCapRouteError(err: unknown): CapRouteError | null {
         const capName: string = typeof rawCapName === 'string' ? rawCapName : '(unknown)'
 
         // Build a minimal object with the same shape — enough for the formatter.
-        const synthetic = Object.assign(new CapRouteError(capName, undefined, {
-          reason,
-          rejected,
-          ...(typeof nodeId === 'string' ? { nodeId } : {}),
-        }), {
-          // Override message from the original if available
-          message: typeof message === 'string' ? message : '(duck-typed CapRouteError)',
-        })
+        const synthetic = Object.assign(
+          new CapRouteError(capName, undefined, {
+            reason,
+            rejected,
+            ...(typeof nodeId === 'string' ? { nodeId } : {}),
+          }),
+          {
+            // Override message from the original if available
+            message: typeof message === 'string' ? message : '(duck-typed CapRouteError)',
+          },
+        )
         return synthetic
       }
     }

package/src/api/trpc/client-ip.ts

@@ -53,6 +53,23 @@ export function extractClientIp(req: ClientRequest | undefined): string | null {
   return null
 }
 
+/**
+ * Best-effort read of the originating client's `User-Agent` header. Both
+ * request shapes in the union (`FastifyRequest` and the raw WS-transport
+ * `IncomingMessage`) expose `.headers['user-agent']`. Returns `null` when
+ * absent (mesh-originated calls carry no HTTP request, and some clients
+ * omit the header). Used by the `webrtc-session` mount to tag a browser
+ * subscriber's broker attribution with the viewer's UA — the SERVER reads
+ * it from the request context; any client-supplied value is ignored.
+ */
+export function extractUserAgent(req: ClientRequest | undefined): string | null {
+  if (!req) return null
+  const ua = req.headers['user-agent']
+  const value = Array.isArray(ua) ? ua[0] : ua
+  if (typeof value === 'string' && value.length > 0) return value
+  return null
+}
+
 /**
  * Strip an IPv4-mapped IPv6 prefix (`::ffff:192.168.1.5` → `192.168.1.5`)
  * and any zone id (`fe80::1%en0` → `fe80::1`) so the range checks below

package/src/api/trpc/core-cap-bridge.ts

@@ -73,7 +73,9 @@ function isProcedureNode(value: unknown): value is ProcedureNode {
   // stores the procedure function directly, not a wrapper object.
   if (value === null || (typeof value !== 'object' && typeof value !== 'function')) return false
   const def: unknown = (value as { _def?: unknown })._def
-  return def !== null && typeof def === 'object' && (def as { procedure?: unknown }).procedure === true
+  return (
+    def !== null && typeof def === 'object' && (def as { procedure?: unknown }).procedure === true
+  )
 }
 
 interface DiscoveredProcedure {