@memberjunction/server 5.42.0 → 5.44.0

package/src/__tests__/meetingRecordingRegistration.test.ts

@@ -0,0 +1,248 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { IMetadataProvider, UserInfo } from '@memberjunction/core';
+
+// ── Mocks ──────────────────────────────────────────────────────────────────
+// The helper uses `RunView.FromMetadataProvider(provider).RunView(...)` for conversation lookups and
+// `FileStorageEngine.Instance` for storage-account/driver/upload. We stub both so the test is pure
+// (no DB, no network, no LiveKit/storage SDK).
+
+const runViewMock = vi.fn();
+
+vi.mock('@memberjunction/core', async (importOriginal) => {
+  const actual = await importOriginal<Record<string, unknown>>();
+  class RunView {
+    static FromMetadataProvider() {
+      return { RunView: runViewMock };
+    }
+    RunView = runViewMock;
+  }
+  return { ...actual, RunView, LogError: vi.fn(), LogStatus: vi.fn() };
+});
+
+// FileStorageEngine — a configurable fake. Tests reset its behavior in beforeEach.
+const storage = {
+  accountsByProvider: new Map<string, Array<{ ID: string }>>(),
+  getObject: vi.fn(async () => Buffer.from('mp4-bytes')),
+  uploadFile: vi.fn(async () => ({ FileID: 'copied-file', StoragePath: 'meeting-recordings/2026/x.mp4' })),
+};
+
+vi.mock('@memberjunction/storage', () => ({
+  FileStorageEngine: {
+    Instance: {
+      Config: vi.fn(async () => undefined),
+      GetAccountsByProviderID: (id: string) => storage.accountsByProvider.get(id) ?? [],
+      GetDriver: vi.fn(async () => ({ GetObject: storage.getObject })),
+      UploadFile: (...args: unknown[]) => storage.uploadFile(...args),
+    },
+  },
+}));
+
+vi.mock('@memberjunction/core-entities', async (importOriginal) => {
+  const actual = await importOriginal<Record<string, unknown>>();
+  return { ...actual };
+});
+
+import {
+  registerMeetingRecordingFile,
+  resolveMeetingConversation,
+  type MeetingRecordingEgressResult,
+} from '../resolvers/meetingRecordingRegistration';
+
+// ── Fakes ──────────────────────────────────────────────────────────────────
+
+const user = { ID: 'U1', Name: 'Amith', Email: 'amith@x.com' } as unknown as UserInfo;
+
+/** A fake BaseEntity for Conversations / Files — records the values set on it. */
+class FakeEntity {
+  public fields: Record<string, unknown> = {};
+  public ID = 'new-id';
+  public saved = false;
+  public loadedID: string | null = null;
+  constructor(public kind: 'conversation' | 'file', private saveResult = true) {}
+  NewRecord() {}
+  async Load(id: string) { this.loadedID = id; return true; }
+  async Save() { this.saved = this.saveResult; return this.saveResult; }
+  get LatestResult() { return { CompleteMessage: 'save failed' }; }
+  // Conversation fields
+  set UserID(v: string) { this.fields.UserID = v; }
+  set Name(v: string) { this.fields.Name = v; }
+  set Type(v: string) { this.fields.Type = v; }
+  set ExternalID(v: string) { this.fields.ExternalID = v; }
+  set ApplicationScope(v: string) { this.fields.ApplicationScope = v; }
+  set RecordingFileID(v: string) { this.fields.RecordingFileID = v; }
+  get RecordingFileID() { return this.fields.RecordingFileID as string; }
+  set EgressID(v: string) { this.fields.EgressID = v; }
+  get EgressID() { return this.fields.EgressID as string; }
+  // File fields
+  set ContentType(v: string) { this.fields.ContentType = v; }
+  set ProviderID(v: string) { this.fields.ProviderID = v; }
+  set ProviderKey(v: string) { this.fields.ProviderKey = v; }
+  set Status(v: string) { this.fields.Status = v; }
+}
+
+/** Builds a provider whose GetEntityObject hands back fresh fakes and records the created Files row. */
+function makeProvider(opts: { fileSaveOk?: boolean } = {}) {
+  const created: { conversation: FakeEntity[]; file: FakeEntity[] } = { conversation: [], file: [] };
+  const provider = {
+    GetEntityObject: vi.fn(async (entityName: string) => {
+      if (entityName === 'MJ: Files') {
+        const f = new FakeEntity('file', opts.fileSaveOk ?? true);
+        f.ID = 'file-123';
+        created.file.push(f);
+        return f;
+      }
+      const c = new FakeEntity('conversation');
+      c.ID = 'conv-new';
+      created.conversation.push(c);
+      return c;
+    }),
+  } as unknown as IMetadataProvider;
+  return { provider, created };
+}
+
+const egress: MeetingRecordingEgressResult = {
+  EgressID: 'eg-1',
+  RoomName: 'room-1',
+  OutputLocation: 'room-1/2026.mp4',
+  OutputSizeBytes: 1234,
+};
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.unstubAllEnvs();
+  runViewMock.mockResolvedValue({ Success: true, Results: [] });
+  storage.accountsByProvider = new Map([['prov-sink', [{ ID: 'acct-sink' }]]]);
+  process.env.MJ_MEETING_RECORDING_STORAGE_PROVIDER = 'prov-sink';
+  delete process.env.MJ_MEETING_RECORDING_CANONICAL_STORAGE_PROVIDER;
+});
+
+describe('registerMeetingRecordingFile', () => {
+  it('resolves the conversation, creates the Files row pointing at the sink, and stamps the Conversation', async () => {
+    // First RunView (by EgressID) → no match; second (by RoomName) → an existing conversation.
+    runViewMock
+      .mockResolvedValueOnce({ Success: true, Results: [] })
+      .mockResolvedValueOnce({ Success: true, Results: [{ ID: 'conv-existing' }] });
+
+    const { provider, created } = makeProvider();
+    const result = await registerMeetingRecordingFile(egress, user, provider);
+
+    expect(result.Success).toBe(true);
+    expect(result.RecordingFileID).toBe('file-123');
+    expect(result.ConversationID).toBe('conv-existing');
+
+    // Files row: correct provider/key/content-type/status, pointing directly at the egress output.
+    const file = created.file[0];
+    expect(file.fields.ProviderID).toBe('prov-sink');
+    expect(file.fields.ProviderKey).toBe('room-1/2026.mp4');
+    expect(file.fields.ContentType).toBe('video/mp4');
+    expect(file.fields.Status).toBe('Uploaded');
+    expect(file.saved).toBe(true);
+
+    // Conversation stamped with the file id (loaded by id, then saved).
+    const conv = created.conversation[0];
+    expect(conv.loadedID).toBe('conv-existing');
+    expect(conv.fields.RecordingFileID).toBe('file-123');
+    expect(conv.fields.EgressID).toBe('eg-1');
+    expect(conv.saved).toBe(true);
+
+    // No byte copy in the default v1 path.
+    expect(storage.getObject).not.toHaveBeenCalled();
+    expect(storage.uploadFile).not.toHaveBeenCalled();
+  });
+
+  it('prefers matching the conversation by EgressID when present', async () => {
+    runViewMock.mockResolvedValueOnce({ Success: true, Results: [{ ID: 'conv-by-egress' }] });
+    const { provider } = makeProvider();
+    const result = await registerMeetingRecordingFile(egress, user, provider);
+    expect(result.ConversationID).toBe('conv-by-egress');
+    // Only the EgressID lookup ran (no fall-through to room-name lookup).
+    expect(runViewMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('creates a Meeting-Room Conversation when none exists', async () => {
+    runViewMock.mockResolvedValue({ Success: true, Results: [] }); // neither lookup matches
+    const { provider, created } = makeProvider();
+    const result = await registerMeetingRecordingFile(egress, user, provider);
+    expect(result.Success).toBe(true);
+    const conv = created.conversation[0];
+    expect(conv.fields.Type).toBe('Meeting Room');
+    expect(conv.fields.ExternalID).toBe('room-1');
+    expect(conv.fields.ApplicationScope).toBe('Application');
+  });
+
+  it('returns a graceful failure when the storage provider is not configured', async () => {
+    delete process.env.MJ_MEETING_RECORDING_STORAGE_PROVIDER;
+    const { provider } = makeProvider();
+    const result = await registerMeetingRecordingFile(egress, user, provider);
+    expect(result.Success).toBe(false);
+    expect(result.ErrorMessage).toMatch(/MJ_MEETING_RECORDING_STORAGE_PROVIDER/);
+    expect(result.RecordingFileID).toBeUndefined();
+  });
+
+  it('returns a graceful failure when no account is linked to the configured provider', async () => {
+    storage.accountsByProvider = new Map(); // no accounts for prov-sink
+    const { provider } = makeProvider();
+    const result = await registerMeetingRecordingFile(egress, user, provider);
+    expect(result.Success).toBe(false);
+    expect(result.ErrorMessage).toMatch(/No active MJStorage account/i);
+  });
+
+  it('returns a graceful failure when the egress has no output yet', async () => {
+    const { provider } = makeProvider();
+    const result = await registerMeetingRecordingFile({ ...egress, OutputLocation: undefined }, user, provider);
+    expect(result.Success).toBe(false);
+    expect(result.ErrorMessage).toMatch(/no output/i);
+  });
+
+  describe('copy-to-canonical (the "copy into Box" option)', () => {
+    it('copies the MP4 into a differing canonical provider and points the Files row there', async () => {
+      storage.accountsByProvider = new Map([
+        ['prov-sink', [{ ID: 'acct-sink' }]],
+        ['prov-canonical', [{ ID: 'acct-canonical' }]],
+      ]);
+      process.env.MJ_MEETING_RECORDING_CANONICAL_STORAGE_PROVIDER = 'prov-canonical';
+      runViewMock.mockResolvedValueOnce({ Success: true, Results: [{ ID: 'conv-1' }] });
+
+      const { provider, created } = makeProvider();
+      const result = await registerMeetingRecordingFile(egress, user, provider);
+
+      expect(result.Success).toBe(true);
+      // Bytes were read from the sink and uploaded into the canonical provider.
+      expect(storage.getObject).toHaveBeenCalledWith({ fullPath: 'room-1/2026.mp4' });
+      expect(storage.uploadFile).toHaveBeenCalledOnce();
+
+      // The Files row points at the canonical provider + its uploaded key.
+      const file = created.file[0];
+      expect(file.fields.ProviderID).toBe('prov-canonical');
+      expect(file.fields.ProviderKey).toBe('meeting-recordings/2026/x.mp4');
+    });
+
+    it('does NOT copy when the canonical provider equals the sink provider', async () => {
+      process.env.MJ_MEETING_RECORDING_CANONICAL_STORAGE_PROVIDER = 'prov-sink'; // same as sink
+      runViewMock.mockResolvedValueOnce({ Success: true, Results: [{ ID: 'conv-1' }] });
+      const { provider, created } = makeProvider();
+      const result = await registerMeetingRecordingFile(egress, user, provider);
+      expect(result.Success).toBe(true);
+      expect(storage.getObject).not.toHaveBeenCalled();
+      expect(created.file[0].fields.ProviderID).toBe('prov-sink');
+    });
+  });
+
+  it('fails gracefully (no throw) when the Files row save fails', async () => {
+    runViewMock.mockResolvedValueOnce({ Success: true, Results: [{ ID: 'conv-1' }] });
+    const { provider } = makeProvider({ fileSaveOk: false });
+    const result = await registerMeetingRecordingFile(egress, user, provider);
+    expect(result.Success).toBe(false);
+    expect(result.ErrorMessage).toMatch(/Files row/i);
+  });
+});
+
+describe('resolveMeetingConversation', () => {
+  it('falls back to creating a conversation when neither lookup matches', async () => {
+    runViewMock.mockResolvedValue({ Success: true, Results: [] });
+    const { provider, created } = makeProvider();
+    const id = await resolveMeetingConversation(egress, user, provider);
+    expect(id).toBe('conv-new');
+    expect(created.conversation).toHaveLength(1);
+  });
+});

package/src/agentSessions/SessionJanitor.ts

@@ -228,8 +228,22 @@ export class SessionJanitor extends BaseSingleton<SessionJanitor> implements ISh
             if (page.length === 0) {
                 break;
             }
+            // Batch-load every channel for this whole page of sessions in ONE query, then hand each
+            // session its own slice to CloseSession — avoids the N+1 channel read (one RunView per
+            // closing session) that tripped the sequential / multiple-same-entity telemetry.
+            const channelsBySession = await this.sessionManager.LoadActiveChannelsBySession(
+                page.map(s => s.ID),
+                systemUser,
+                provider,
+            );
             for (const session of page) {
-                const closed = await this.sessionManager.CloseSession(session.ID, systemUser, provider, closeReason);
+                const closed = await this.sessionManager.CloseSession(
+                    session.ID,
+                    systemUser,
+                    provider,
+                    closeReason,
+                    channelsBySession.get(session.ID.toLowerCase()) ?? [],
+                );
                 if (closed) {
                     closedCount++;
                 }

package/src/agentSessions/SessionManager.ts

@@ -137,6 +137,7 @@ export class SessionManager {
         contextUser: UserInfo,
         provider: IMetadataProvider,
         closeReason: SessionCloseReason = 'Explicit',
+        preloadedChannels?: MJAIAgentSessionChannelEntity[],
     ): Promise<boolean> {
         const session = await this.loadSession(agentSessionID, contextUser, provider);
         if (!session) {
@@ -156,7 +157,7 @@ export class SessionManager {
         if (!closed) {
             return false;
         }
-        await this.disconnectChannels(agentSessionID, contextUser, provider);
+        await this.disconnectChannels(agentSessionID, contextUser, provider, preloadedChannels);
         await this.finalizeObservabilityRuns(session, contextUser, provider);
         await this.notifyChannelPluginsSessionClosed(agentSessionID, closeReason);
         return true;
@@ -180,6 +181,9 @@ export class SessionManager {
                     AgentID: session.AgentID,
                     UserID: session.UserID,
                     ConversationID: session.ConversationID ?? null,
+                    // Hand the verbatim per-session config blob to data-aware channels (e.g. the Media
+                    // channel reads a per-session mediaCollectionID override from it). Opaque here.
+                    AgentSessionConfig: session.Config_ ?? null,
                 },
                 contextUser,
                 provider,
@@ -376,24 +380,72 @@ export class SessionManager {
         agentSessionID: string,
         contextUser: UserInfo,
         provider: IMetadataProvider,
+        preloadedChannels?: MJAIAgentSessionChannelEntity[],
     ): Promise<void> {
+        // Sweep callers (the janitor) close a whole page of sessions at once and pre-load every
+        // session's channels in ONE batched query (see LoadActiveChannelsBySession), passing this
+        // session's slice here to avoid an N+1 channel read (one RunView per closing session).
+        // Every other close path passes nothing and reads just this session's channels.
+        const channels = preloadedChannels
+            ?? await this.loadActiveChannels([agentSessionID], contextUser, provider);
+        const now = new Date();
+        for (const channel of channels) {
+            channel.Status = 'Disconnected';
+            channel.DisconnectedAt = now;
+            await this.saveOrLog(channel, 'disconnectChannels');
+        }
+    }
+
+    /**
+     * Loads the non-Disconnected channels for one or more sessions in a SINGLE RunView
+     * (`AgentSessionID IN (...)`). Session IDs are server-generated GUIDs (never user input), so
+     * inline interpolation carries no injection risk. Returns [] on empty input or load failure.
+     */
+    private async loadActiveChannels(
+        sessionIDs: string[],
+        contextUser: UserInfo,
+        provider: IMetadataProvider,
+    ): Promise<MJAIAgentSessionChannelEntity[]> {
+        if (sessionIDs.length === 0) {
+            return [];
+        }
+        const inList = sessionIDs.map(id => `'${id}'`).join(',');
         const rv = RunView.FromMetadataProvider(provider);
         const result = await rv.RunView<MJAIAgentSessionChannelEntity>({
             EntityName: SESSION_CHANNEL_ENTITY,
-            ExtraFilter: `AgentSessionID='${agentSessionID}' AND Status <> 'Disconnected'`,
+            ExtraFilter: `AgentSessionID IN (${inList}) AND Status <> 'Disconnected'`,
             ResultType: 'entity_object',
         }, contextUser);
-
         if (!result.Success) {
-            LogError(`SessionManager.disconnectChannels failed to load channels: ${result.ErrorMessage}`);
-            return;
+            LogError(`SessionManager.loadActiveChannels failed to load channels: ${result.ErrorMessage}`);
+            return [];
         }
-        const now = new Date();
-        for (const channel of result.Results) {
-            channel.Status = 'Disconnected';
-            channel.DisconnectedAt = now;
-            await this.saveOrLog(channel, 'disconnectChannels');
+        return result.Results;
+    }
+
+    /**
+     * Batch-loads active channels for many sessions at once and groups them by AgentSessionID
+     * (lowercased), so a sweep can disconnect a whole page of sessions with ONE query instead of
+     * one-per-session. Sessions with no active channels are absent from the map (callers default
+     * to []). Pass each session's slice to {@link CloseSession}'s `preloadedChannels`.
+     */
+    public async LoadActiveChannelsBySession(
+        sessionIDs: string[],
+        contextUser: UserInfo,
+        provider: IMetadataProvider,
+    ): Promise<Map<string, MJAIAgentSessionChannelEntity[]>> {
+        const channels = await this.loadActiveChannels(sessionIDs, contextUser, provider);
+        const bySession = new Map<string, MJAIAgentSessionChannelEntity[]>();
+        for (const channel of channels) {
+            const key = String(channel.AgentSessionID).toLowerCase();
+            const list = bySession.get(key);
+            if (list) {
+                list.push(channel);
+            } else {
+                bySession.set(key, [channel]);
+            }
         }
+        return bySession;
     }
 
     /** True once the per-session coalescing window has elapsed since the last persisted write. */

package/src/agentSessions/index.ts

@@ -7,7 +7,7 @@
  *
  * @module @memberjunction/server
  */
-import { LoadWhiteboardChannelServer, LoadMeetingControlsChannelServer } from '@memberjunction/ai-agents';
+import { LoadWhiteboardChannelServer, LoadMeetingControlsChannelServer, LoadMediaChannelServer, LoadClientContextChannelServer } from '@memberjunction/ai-agents';
 import { LoadRemoteBrowserChannel } from '@memberjunction/remote-browser-server';
 import { LoadSelfHostRemoteBrowser } from '@memberjunction/remote-browser-selfhost';
 import { BindRemoteBrowserGoalEngine } from './remoteBrowserGoalEngine.js';
@@ -17,6 +17,8 @@ import { BindRemoteBrowserGoalEngine } from './remoteBrowserGoalEngine.js';
 // the session lifecycle — `SessionManager.CreateSession` resolves them via the ClassFactory.
 LoadWhiteboardChannelServer();
 LoadMeetingControlsChannelServer();
+LoadMediaChannelServer();
+LoadClientContextChannelServer();
 // Remote Browser native channel (client-direct): the lifecycle-only server channel plugin + the
 // Self-Hosted Chrome backend driver (whose default runner launches a local headless Chromium via
 // Playwright — pulled in transitively through the SelfHost package, documented and acceptable).