@almadar/server 1.0.16 → 1.2.0

package/dist/index.js

@@ -6,6 +6,7 @@ export { default as admin } from 'firebase-admin';
 import { WebSocketServer, WebSocket } from 'ws';
 import { faker } from '@faker-js/faker';
 import { diffSchemas, categorizeRemovals, detectPageContentReduction, isDestructiveChange, hasSignificantPageReduction, requiresConfirmation } from '@almadar/core';
+import { getObservabilityCollector, MemoryManager, SessionManager, getMultiUserManager, createSkillAgent, createUserContext, getStateSyncManager } from '@almadar/agent';
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -176,25 +177,25 @@ function emitEntityEvent(entityType, action, payload) {
   serverEventBus.emit(eventType, payload, { orbital: entityType });
 }
 function debugEventsRouter() {
-  const router = Router();
+  const router2 = Router();
   if (process.env.NODE_ENV !== "development") {
-    return router;
+    return router2;
   }
-  router.get("/event-log", (_req, res) => {
+  router2.get("/event-log", (_req, res) => {
     const limit = parseInt(String(_req.query.limit) || "50", 10);
     const events = serverEventBus.getRecentEvents(limit);
     res.json({ count: events.length, events });
   });
-  router.delete("/event-log", (_req, res) => {
+  router2.delete("/event-log", (_req, res) => {
     serverEventBus.clearEventLog();
     res.json({ cleared: true });
   });
-  router.get("/listeners", (_req, res) => {
+  router2.get("/listeners", (_req, res) => {
     const counts = serverEventBus.getListenerCounts();
     const total = Object.values(counts).reduce((sum, n) => sum + n, 0);
     res.json({ total, events: counts });
   });
-  return router;
+  return router2;
 }
 var firebaseApp = null;
 function initializeFirebase() {
@@ -1590,7 +1591,234 @@ var ValidationStore = class {
     });
   }
 };
+var memoryManager = null;
+function getMemoryManager() {
+  if (!memoryManager) {
+    memoryManager = new MemoryManager({
+      db,
+      usersCollection: "agent_memory_users",
+      projectsCollection: "agent_memory_projects",
+      generationsCollection: "agent_memory_generations",
+      patternsCollection: "agent_memory_patterns",
+      interruptsCollection: "agent_memory_interrupts",
+      feedbackCollection: "agent_memory_feedback",
+      checkpointsCollection: "agent_memory_checkpoints",
+      toolPreferencesCollection: "agent_memory_tool_preferences"
+    });
+  }
+  return memoryManager;
+}
+function resetMemoryManager() {
+  memoryManager = null;
+}
+var sessionManager = null;
+function createFirestoreAdapter(firestore) {
+  return firestore;
+}
+function getSessionManager() {
+  if (!sessionManager) {
+    sessionManager = new SessionManager({
+      mode: "firestore",
+      firestoreDb: createFirestoreAdapter(db),
+      memoryManager: getMemoryManager(),
+      // Enable GAP-002D
+      compactionConfig: {
+        maxTokens: 15e4,
+        keepRecentMessages: 10,
+        strategy: "last"
+      }
+    });
+  }
+  return sessionManager;
+}
+function resetSessionManager() {
+  sessionManager = null;
+}
+async function createServerSkillAgent(options) {
+  const memoryManager2 = getMemoryManager();
+  getSessionManager();
+  const observability = getObservabilityCollector();
+  const multiUser = getMultiUserManager();
+  if (options.threadId) {
+    const access = multiUser.canAccessSession(options.threadId, {
+      userId: options.userId,
+      roles: ["user"]
+    });
+    if (!access.allowed) {
+      throw new Error(`Access denied: ${access.reason}`);
+    }
+  }
+  observability.startSession(options.threadId ?? "new", options.userId);
+  try {
+    const result = await createSkillAgent({
+      ...options,
+      memoryManager: memoryManager2,
+      // GAP-001: Enable memory
+      userId: options.userId,
+      // GAP-002D: Session → Memory sync
+      appId: options.appId
+    });
+    if (result.threadId) {
+      multiUser.assignSessionOwnership(result.threadId, options.userId);
+    }
+    observability.recordEvent({
+      type: "session_start",
+      sessionId: result.threadId,
+      userId: options.userId,
+      payload: { skill: options.skill }
+    });
+    return result;
+  } catch (error) {
+    observability.recordError(options.threadId ?? "new", error);
+    throw error;
+  }
+}
+async function multiUserMiddleware(req, res, next) {
+  const userId = req.user?.uid;
+  if (!userId) {
+    res.status(401).json({ error: "Authentication required" });
+    return;
+  }
+  req.userContext = createUserContext(userId, {
+    orgId: req.user?.orgId,
+    roles: req.user?.roles ?? ["user"]
+  });
+  const originalJson = res.json.bind(res);
+  res.json = (body) => {
+    if (body && typeof body === "object" && "threadId" in body) {
+      const multiUser = getMultiUserManager();
+      multiUser.assignSessionOwnership(
+        body.threadId,
+        userId
+      );
+    }
+    return originalJson(body);
+  };
+  next();
+}
+async function verifyFirebaseAuth(req, res, next) {
+  const authHeader = req.headers.authorization;
+  if (!authHeader?.startsWith("Bearer ")) {
+    res.status(401).json({ error: "No token provided" });
+    return;
+  }
+  const token = authHeader.split("Bearer ")[1];
+  try {
+    const decodedToken = await getAuth().verifyIdToken(token);
+    const user = await getAuth().getUser(decodedToken.uid);
+    req.user = {
+      uid: decodedToken.uid,
+      email: decodedToken.email,
+      roles: user.customClaims?.roles ?? ["user"],
+      orgId: user.customClaims?.orgId
+    };
+    next();
+  } catch (error) {
+    console.error("Token verification failed:", error);
+    res.status(401).json({ error: "Invalid token" });
+  }
+}
+function setupStateSyncWebSocket(io) {
+  const stateSync = getStateSyncManager();
+  io.use(async (socket, next) => {
+    try {
+      const token = socket.handshake.auth.token;
+      if (!token) {
+        return next(new Error("Authentication required"));
+      }
+      const decodedToken = await getAuth().verifyIdToken(token);
+      const user = await getAuth().getUser(decodedToken.uid);
+      socket.data.user = {
+        uid: decodedToken.uid,
+        roles: user.customClaims?.roles ?? ["user"],
+        orgId: user.customClaims?.orgId
+      };
+      next();
+    } catch (error) {
+      console.error("Socket auth failed:", error);
+      next(new Error("Invalid token"));
+    }
+  });
+  io.on("connection", (socket) => {
+    const userId = socket.data.user.uid;
+    const clientId = socket.handshake.auth.clientId;
+    console.log(`[StateSync] Client ${clientId} connected for user ${userId}`);
+    stateSync.updateConfig({ clientId });
+    socket.join(`user:${userId}`);
+    socket.on("stateChange", (...args) => {
+      const event = args[0];
+      const multiUser = getMultiUserManager();
+      if (!multiUser.isSessionOwner(event.threadId, userId)) {
+        socket.emit("error", { message: "Not session owner" });
+        return;
+      }
+      stateSync.receiveRemoteChange(event);
+      socket.to(`user:${userId}`).emit("remoteChange", event);
+    });
+    stateSync.on("syncRequired", (changes) => {
+      socket.emit("syncBatch", changes);
+    });
+    socket.on("disconnect", () => {
+      console.log(`[StateSync] Client ${clientId} disconnected`);
+      socket.leave(`user:${userId}`);
+    });
+  });
+}
+var router = Router();
+router.get("/metrics", async (req, res) => {
+  try {
+    const collector = getObservabilityCollector();
+    const snapshot = collector.getPerformanceSnapshot();
+    res.json(snapshot);
+  } catch (error) {
+    console.error("Metrics error:", error);
+    res.status(500).json({ error: "Failed to get metrics" });
+  }
+});
+router.get("/health", async (req, res) => {
+  try {
+    const collector = getObservabilityCollector();
+    const health = await collector.healthCheck();
+    const allHealthy = health.every((h) => h.status === "healthy");
+    res.status(allHealthy ? 200 : 503).json({
+      status: allHealthy ? "healthy" : "degraded",
+      timestamp: Date.now(),
+      checks: health
+    });
+  } catch (error) {
+    console.error("Health check error:", error);
+    res.status(500).json({
+      status: "unhealthy",
+      error: "Health check failed"
+    });
+  }
+});
+router.get("/sessions/:threadId/telemetry", async (req, res) => {
+  try {
+    const collector = getObservabilityCollector();
+    const telemetry = collector.getSessionTelemetry(req.params.threadId);
+    if (!telemetry) {
+      res.status(404).json({ error: "Session not found" });
+      return;
+    }
+    res.json(telemetry);
+  } catch (error) {
+    console.error("Telemetry error:", error);
+    res.status(500).json({ error: "Failed to get telemetry" });
+  }
+});
+router.get("/active-sessions", async (req, res) => {
+  try {
+    const collector = getObservabilityCollector();
+    const sessions = collector.getActiveSessions();
+    res.json(sessions);
+  } catch (error) {
+    console.error("Active sessions error:", error);
+    res.status(500).json({ error: "Failed to get active sessions" });
+  }
+});
+var observability_default = router;
 
-export { AppError, ChangeSetStore, ConflictError, EventBus, ForbiddenError, MockDataService, NotFoundError, SchemaProtectionService, SchemaStore, SnapshotStore, UnauthorizedError, ValidationError, ValidationStore, applyFiltersToQuery, asyncHandler, authenticateFirebase, closeWebSocketServer, dataService, db, debugEventsRouter, emitEntityEvent, env, errorHandler, extractPaginationParams, fromFirestoreFormat, getAuth, getConnectedClientCount, getFirestore, getWebSocketServer, logger, mockDataService, notFoundHandler, parseQueryFilters, seedMockData, serverEventBus, setupEventBroadcast, toFirestoreFormat, validateBody, validateParams, validateQuery };
+export { AppError, ChangeSetStore, ConflictError, EventBus, ForbiddenError, MockDataService, NotFoundError, SchemaProtectionService, SchemaStore, SnapshotStore, UnauthorizedError, ValidationError, ValidationStore, applyFiltersToQuery, asyncHandler, authenticateFirebase, closeWebSocketServer, createServerSkillAgent, dataService, db, debugEventsRouter, emitEntityEvent, env, errorHandler, extractPaginationParams, fromFirestoreFormat, getMemoryManager as getAgentMemoryManager, getSessionManager as getAgentSessionManager, getAuth, getConnectedClientCount, getFirestore, getMemoryManager, getSessionManager, getWebSocketServer, logger, mockDataService, multiUserMiddleware, notFoundHandler, observability_default as observabilityRouter, parseQueryFilters, resetMemoryManager, resetSessionManager, seedMockData, serverEventBus, setupEventBroadcast, setupStateSyncWebSocket, toFirestoreFormat, validateBody, validateParams, validateQuery, verifyFirebaseAuth };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map