@memberjunction/server 6.1.0-edge.5 → 6.1.0-edge.7

package/src/__tests__/EntityRecordNameResolver.fieldSecurity.test.ts

@@ -0,0 +1,118 @@
+// ResolverBase transitively pulls in type-graphql decorators, which need the
+// Reflect.metadata polyfill at import time.
+import 'reflect-metadata';
+import { describe, it, expect, vi } from 'vitest';
+import { CompositeKey } from '@memberjunction/core';
+import type { DatabaseProviderBase, EntityInfo, UserInfo } from '@memberjunction/core';
+import { EntityRecordNameResolver } from '../resolvers/EntityRecordNameResolver.js';
+
+/**
+ * `GetEntityRecordName` must not hand back a name the caller cannot READ.
+ *
+ * This resolver predates field-level security and took no user context at all, which made it an
+ * open side channel: the name never travelled through `MapFieldNamesToCodeNames`, the boundary
+ * that strips denied fields, so a caller denied READ on an entity's name field could still obtain
+ * that name from here.
+ *
+ * FLS turned the latent gap into a live bypass, and the shape of it is worth remembering: the
+ * form-field FK control falls through to this query PRECISELY WHEN the joined display column is
+ * denied. The fallback that exists to handle a denial was the thing that defeated it. Found in
+ * manual Phase 5 testing — a Contract form showed its Client's name while the grid, correctly,
+ * did not.
+ */
+
+const DENIED_USER = { ID: 'u-1', Email: 'restricted@test' } as unknown as UserInfo;
+
+/** An entity whose name field is denied or allowed, per the flag. */
+function entityInfo(opts: { fls: boolean; deniedNames?: string[]; nameField?: string }): EntityInfo {
+    const nameFieldName = opts.nameField ?? 'Name';
+    return {
+        Name: 'Clients',
+        EnableFieldLevelSecurity: opts.fls,
+        Fields: [
+            { Name: 'ID', IsNameField: false },
+            { Name: nameFieldName, IsNameField: true },
+            { Name: 'Industry', IsNameField: false },
+        ],
+        GetDeniedReadFields: () => new Set(opts.deniedNames ?? []),
+    } as unknown as EntityInfo;
+}
+
+/** A provider that would happily return the name — the resolver must decide not to ask. */
+function providerWith(entity: EntityInfo, getName = vi.fn().mockResolvedValue('Acme Manufacturing')) {
+    return {
+        Entities: [entity],
+        GetEntityRecordName: getName,
+    } as unknown as DatabaseProviderBase & { GetEntityRecordName: typeof getName };
+}
+
+/** Exposes the inner method so the test does not need a GraphQL context. */
+class Probe extends EntityRecordNameResolver {
+    public Inner(md: DatabaseProviderBase, entityName: string, pk: CompositeKey, user?: UserInfo) {
+        // The resolver resolves the acting user from the payload; supply it directly.
+        vi.spyOn(this as never, 'GetUserFromPayload').mockReturnValue(user as never);
+        return this.InnerGetEntityRecordName(md, entityName, pk, { email: 'restricted@test' } as never);
+    }
+}
+
+const KEY = new CompositeKey([{ FieldName: 'ID', Value: 'c-1' }]);
+
+describe('GetEntityRecordName — field-security gate', () => {
+    it('withholds the name when the name field is read-denied', async () => {
+        const getName = vi.fn().mockResolvedValue('Acme Manufacturing');
+        const md = providerWith(entityInfo({ fls: true, deniedNames: ['name'] }), getName);
+
+        const result = await new Probe().Inner(md, 'Clients', KEY, DENIED_USER);
+
+        expect(result.Success).toBe(false);
+        expect(result.RecordName).toBeUndefined();
+        // Not merely filtered after the fact — the lookup must not run at all. The provider's
+        // record-name cache is keyed by entity + primary key and NOT by user, so a name fetched
+        // here would be visible to any later caller.
+        expect(getName).not.toHaveBeenCalled();
+    });
+
+    it('returns the name when the user may read the name field', async () => {
+        const md = providerWith(entityInfo({ fls: true, deniedNames: ['industry'] }));
+
+        const result = await new Probe().Inner(md, 'Clients', KEY, DENIED_USER);
+
+        expect(result.Success).toBe(true);
+        expect(result.RecordName).toBe('Acme Manufacturing');
+    });
+
+    it('is inert when the entity has field security switched off', async () => {
+        // Nearly every entity. A denial set that would otherwise match must not apply.
+        const md = providerWith(entityInfo({ fls: false, deniedNames: ['name'] }));
+
+        const result = await new Probe().Inner(md, 'Clients', KEY, DENIED_USER);
+
+        expect(result.Success).toBe(true);
+        expect(result.RecordName).toBe('Acme Manufacturing');
+    });
+
+    it('honours a designated name field that is not literally called "Name"', async () => {
+        const md = providerWith(entityInfo({ fls: true, nameField: 'Title', deniedNames: ['title'] }));
+
+        const result = await new Probe().Inner(md, 'Clients', KEY, DENIED_USER);
+
+        expect(result.Success).toBe(false);
+    });
+
+    it('passes the acting user to the provider so row-level security has an identity', async () => {
+        const getName = vi.fn().mockResolvedValue('Acme Manufacturing');
+        const md = providerWith(entityInfo({ fls: true }), getName);
+
+        await new Probe().Inner(md, 'Clients', KEY, DENIED_USER);
+
+        expect(getName).toHaveBeenCalledWith('Clients', expect.anything(), DENIED_USER);
+    });
+
+    it('does not disclose which of "missing" or "restricted" applies', async () => {
+        // The denial status must read the same as a genuine not-found, so the query cannot be
+        // used to probe for which entities carry restricted name fields.
+        const denied = await new Probe().Inner(
+            providerWith(entityInfo({ fls: true, deniedNames: ['name'] })), 'Clients', KEY, DENIED_USER);
+        expect(denied.Status).not.toMatch(/denied|permission|restricted|field.security/i);
+    });
+});

package/src/__tests__/RealtimeClientSessionResolver.test.ts

@@ -2769,6 +2769,26 @@ describe('RealtimeClientSessionResolver — app awareness (applicationId / appCo
         const relayArg = executeRelayedToolMock.mock.calls[0][0] as { AllowedAgents?: Array<{ agentId: string }> };
         expect(relayArg.AllowedAgents?.map(a => a.agentId)).toEqual(['skip-1']);
     });
+
+    it('passes the persisted directActions from the session config into ExecuteRelayedTool', async () => {
+        currentProvider = makeProvider(() =>
+            makeSessionEntity({
+                Config_: JSON.stringify({
+                    targetAgentID: 'lead-1',
+                    directActions: { enabled: true, actionNames: ['SendEmail'] },
+                }),
+            }),
+        );
+        executeRelayedToolMock.mockResolvedValue({ ResultJson: '{"ok":true}', Success: true });
+        const resolver = makeResolver();
+
+        await resolver.ExecuteRealtimeSessionTool(
+            'session-1', 'call-1', 'SendEmail', '{"To":"user@test.com"}', makeCtx(), makePubSub(),
+        );
+
+        const relayArg = executeRelayedToolMock.mock.calls[0][0] as { DirectActions?: { enabled: boolean; actionNames: string[] } };
+        expect(relayArg.DirectActions).toEqual({ enabled: true, actionNames: ['SendEmail'] });
+    });
 });
 
 describe('RealtimeClientSessionResolver — scoped-anonymous elevation (issue #3371)', () => {

package/src/__tests__/RealtimeSdpBrokerHandler.test.ts

@@ -0,0 +1,191 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import type { Request, Response, NextFunction } from 'express';
+import { MJGlobal, RegisterClass } from '@memberjunction/global';
+import { BaseRealtimeModel, RealtimeProxyRegistry, IRealtimeSession, RealtimeSessionParams } from '@memberjunction/ai';
+import { createRealtimeSdpBrokerRouter, createOpenAILiveBrokerRouter, requireTicket } from '../rest/RealtimeSdpBrokerHandler.js';
+
+@RegisterClass(BaseRealtimeModel, 'MockOpenAILiveForBrokerTest', 10)
+class MockOpenAILiveForBrokerTest extends BaseRealtimeModel {
+    public static LastSessionConfig: Record<string, unknown> | undefined;
+
+    public override async StartSession(_params: RealtimeSessionParams): Promise<IRealtimeSession> {
+        throw new Error('Not needed in broker test');
+    }
+
+    public override async ExchangeWebRtcSdp(
+        offerSdp: string,
+        sessionConfig?: Record<string, unknown>
+    ): Promise<{ answerSdp: string; sessionId: string; prebillSeconds: number }> {
+        MockOpenAILiveForBrokerTest.LastSessionConfig = sessionConfig;
+        if (offerSdp === 'trigger_error') {
+            throw new Error('Upstream OpenAI internal error details');
+        }
+        return {
+            answerSdp: `mock_answer_for_${offerSdp}`,
+            sessionId: 'sess_mock_123',
+            prebillSeconds: 15,
+        };
+    }
+}
+
+function makeMockReqRes(query: Record<string, string>, body: unknown): {
+    req: Request;
+    res: Response;
+    getStatus: () => number;
+    getJson: () => Record<string, unknown>;
+} {
+    let statusCode = 200;
+    let jsonBody: Record<string, unknown> = {};
+
+    const res = {
+        locals: {} as Record<string, unknown>,
+        status(code: number): Response {
+            statusCode = code;
+            return res as unknown as Response;
+        },
+        json(data: Record<string, unknown>): Response {
+            jsonBody = data;
+            return res as unknown as Response;
+        },
+    };
+
+    const req = {
+        method: 'POST',
+        url: '/',
+        query,
+        body,
+        headers: {},
+        _body: true,
+    };
+
+    return {
+        req: req as unknown as Request,
+        res: res as unknown as Response,
+        getStatus: () => statusCode,
+        getJson: () => jsonBody,
+    };
+}
+
+describe('RealtimeSdpBrokerHandler', () => {
+    let router: ReturnType<typeof createRealtimeSdpBrokerRouter>;
+
+    beforeEach(() => {
+        router = createRealtimeSdpBrokerRouter();
+    });
+
+    it('createOpenAILiveBrokerRouter is backwards-compatible alias', () => {
+        expect(createOpenAILiveBrokerRouter).toBe(createRealtimeSdpBrokerRouter);
+    });
+
+    it('requireTicket middleware rejects missing ticket without calling next()', () => {
+        const { req, res, getStatus, getJson } = makeMockReqRes({}, {});
+        const next = vi.fn();
+        requireTicket(req, res, next as NextFunction);
+        expect(getStatus()).toBe(401);
+        expect(getJson().error).toContain('missing ticket');
+        expect(next).not.toHaveBeenCalled();
+    });
+
+    it('requireTicket middleware rejects invalid ticket without calling next()', () => {
+        const { req, res, getStatus, getJson } = makeMockReqRes({ ticket: 'non-existent-ticket' }, {});
+        const next = vi.fn();
+        requireTicket(req, res, next as NextFunction);
+        expect(getStatus()).toBe(401);
+        expect(getJson().error).toContain('invalid or expired ticket');
+        expect(next).not.toHaveBeenCalled();
+    });
+
+    it('rejects missing ticket with 401', async () => {
+        const { req, res, getStatus, getJson } = makeMockReqRes({}, { sdp: 'v=0...' });
+        // @ts-expect-error reaching the route handler directly
+        await router.handle(req, res, () => {});
+        expect(getStatus()).toBe(401);
+        expect(getJson().error).toContain('missing ticket');
+    });
+
+    it('rejects invalid or expired ticket with 401', async () => {
+        const { req, res, getStatus, getJson } = makeMockReqRes({ ticket: 'non-existent-ticket' }, { sdp: 'v=0...' });
+        // @ts-expect-error reaching the route handler directly
+        await router.handle(req, res, () => {});
+        expect(getStatus()).toBe(401);
+        expect(getJson().error).toContain('invalid or expired ticket');
+    });
+
+    it('rejects missing sdp in request body with 400', async () => {
+        const ticket = RealtimeProxyRegistry.Instance.Issue({
+            UpstreamUrl: 'https://api.openai.com/v1/live/sessions',
+            UpstreamAuthHeader: 'test-key',
+            DriverClass: 'MockOpenAILiveForBrokerTest',
+            TTLSeconds: 60,
+        });
+
+        const { req, res, getStatus, getJson } = makeMockReqRes({ ticket: ticket.ID }, {});
+        // @ts-expect-error reaching the route handler directly
+        await router.handle(req, res, () => {});
+        expect(getStatus()).toBe(400);
+        expect(getJson().error).toContain('Missing or invalid sdp');
+    });
+
+    it('exchanges SDP offer for answer with a valid ticket and consumes the ticket', async () => {
+        const serverConfig = { model: 'gpt-live-1', authoritative: true };
+        const ticket = RealtimeProxyRegistry.Instance.Issue({
+            UpstreamUrl: 'https://api.openai.com/v1/live/sessions',
+            UpstreamAuthHeader: 'test-key',
+            DriverClass: 'MockOpenAILiveForBrokerTest',
+            SessionConfig: serverConfig,
+            TTLSeconds: 60,
+        });
+
+        // Client attempts to pass its own session config
+        const clientAttemptedSession = { model: 'tampered-model' };
+        const { req, res, getStatus, getJson } = makeMockReqRes(
+            { ticket: ticket.ID },
+            { sdp: 'offer_123', session: clientAttemptedSession }
+        );
+        // @ts-expect-error reaching the route handler directly
+        await router.handle(req, res, () => {});
+
+        expect(getStatus()).toBe(200);
+        const json = getJson();
+        expect(json.answerSdp).toBe('mock_answer_for_offer_123');
+        expect(json.sessionId).toBe('sess_mock_123');
+        expect(json.prebillSeconds).toBe(15);
+        // Verify server's authoritative session config was passed, not the client's
+        expect(MockOpenAILiveForBrokerTest.LastSessionConfig).toEqual(serverConfig);
+
+        // Ticket is single-use: consuming again should fail
+        const reused = makeMockReqRes({ ticket: ticket.ID }, { sdp: 'offer_123' });
+        // @ts-expect-error reaching the route handler directly
+        await router.handle(reused.req, reused.res, () => {});
+        expect(reused.getStatus()).toBe(401);
+    });
+
+    it('rejects ticket without upstream auth header with 500', async () => {
+        const ticket = RealtimeProxyRegistry.Instance.Issue({
+            UpstreamUrl: 'https://api.openai.com/v1/live/sessions',
+            DriverClass: 'MockOpenAILiveForBrokerTest',
+            TTLSeconds: 60,
+        });
+
+        const { req, res, getStatus, getJson } = makeMockReqRes({ ticket: ticket.ID }, { sdp: 'offer_123' });
+        // @ts-expect-error reaching the route handler directly
+        await router.handle(req, res, () => {});
+        expect(getStatus()).toBe(500);
+        expect(getJson().error).toContain('missing upstream credentials');
+    });
+
+    it('sanitizes 502 error when upstream exchange throws without leaking internal error', async () => {
+        const ticket = RealtimeProxyRegistry.Instance.Issue({
+            UpstreamUrl: 'https://api.openai.com/v1/live/sessions',
+            UpstreamAuthHeader: 'test-key',
+            DriverClass: 'MockOpenAILiveForBrokerTest',
+            TTLSeconds: 60,
+        });
+
+        const { req, res, getStatus, getJson } = makeMockReqRes({ ticket: ticket.ID }, { sdp: 'trigger_error' });
+        // @ts-expect-error reaching the route handler directly
+        await router.handle(req, res, () => {});
+        expect(getStatus()).toBe(502);
+        expect(getJson().error).toBe('Realtime WebRTC handshake failed');
+    });
+});

package/src/__tests__/RemoteBrowserAudioStream.test.ts

@@ -2,7 +2,7 @@
 // polyfill is loaded first. MUST precede any import that pulls in the resolver file.
 import 'reflect-metadata';
 
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { RemoteBrowserCapabilityNotSupportedError } from '@memberjunction/remote-browser-base';
 
 // type-graphql's `@Field()`/`@ObjectType()`/`@Mutation()` decorators need `emitDecoratorMetadata`
@@ -32,14 +32,21 @@ vi.mock('type-graphql', () => {
 });
 
 // --- Mock the live-session engine the resolver drives. A single mutable session object lets each
-//     test script what StartAudioStream/StopAudioStream do (succeed / throw a capability error). ---
+//     test script what StartAudioStream/StopAudioStream (and, for the TTL-sweep tests below,
+//     StartScreencast/StopScreencast) do (succeed / throw a capability error). ---
 interface FakeLiveSession {
   StartAudioStream: ReturnType<typeof vi.fn>;
   StopAudioStream: ReturnType<typeof vi.fn>;
+  StartScreencast: ReturnType<typeof vi.fn>;
+  StopScreencast: ReturnType<typeof vi.fn>;
+  GetCurrentUrl: ReturnType<typeof vi.fn>;
 }
 const liveSession: FakeLiveSession = {
   StartAudioStream: vi.fn(async () => undefined),
   StopAudioStream: vi.fn(async () => undefined),
+  StartScreencast: vi.fn(async () => undefined),
+  StopScreencast: vi.fn(async () => undefined),
+  GetCurrentUrl: vi.fn(() => 'https://example.com'),
 };
 const startSessionMock = vi.fn(async () => liveSession);
 const getSessionMock = vi.fn(() => liveSession as FakeLiveSession | undefined);
@@ -116,6 +123,8 @@ describe('RemoteBrowserActionResolver — audio stream', () => {
     resolver = new TestableResolver();
     liveSession.StartAudioStream.mockReset().mockResolvedValue(undefined);
     liveSession.StopAudioStream.mockReset().mockResolvedValue(undefined);
+    liveSession.StartScreencast.mockReset().mockResolvedValue(undefined);
+    liveSession.StopScreencast.mockReset().mockResolvedValue(undefined);
     startSessionMock.mockReset().mockResolvedValue(liveSession);
     getSessionMock.mockReset().mockReturnValue(liveSession);
   });
@@ -194,3 +203,73 @@ describe('RemoteBrowserActionResolver — audio stream', () => {
     await expect(resolver.StopRemoteBrowserAudioStream('sess-1', ctx)).resolves.toBe(true);
   });
 });
+
+describe('RemoteBrowserActionResolver — stream idempotency-map TTL sweep', () => {
+  // Regression coverage for the Round 13 memory-leak-audit finding: `startedScreencasts` /
+  // `startedAudioStreams` are process-lifetime maps (the resolver is instantiated once per process by
+  // type-graphql's default container) that only ever shrink via an explicit Stop call. A session that
+  // crashes/disconnects/times out before calling Stop — a normal occurrence, not an edge case — used to
+  // leave its entry behind forever. These tests drive the maps past their internal TTL (see
+  // MAX_STREAM_ENTRY_AGE_MS in RemoteBrowserActionResolver.ts) WITHOUT ever calling Stop, and assert the
+  // swept entry no longer blocks a fresh Start — proving the leak is now bounded rather than permanent.
+  let resolver: TestableResolver;
+
+  beforeEach(() => {
+    resolver = new TestableResolver();
+    liveSession.StartAudioStream.mockReset().mockResolvedValue(undefined);
+    liveSession.StopAudioStream.mockReset().mockResolvedValue(undefined);
+    liveSession.StartScreencast.mockReset().mockResolvedValue(undefined);
+    liveSession.StopScreencast.mockReset().mockResolvedValue(undefined);
+    startSessionMock.mockReset().mockResolvedValue(liveSession);
+    getSessionMock.mockReset().mockReturnValue(liveSession);
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('audio stream: a crashed session (no Stop call) is forgotten after the TTL, so a later Start re-invokes StartAudioStream', async () => {
+    const pubSub = makePubSub();
+    await resolver.StartRemoteBrowserAudioStream('sess-crash-1', ctx, pubSub as never);
+    expect(liveSession.StartAudioStream).toHaveBeenCalledTimes(1);
+
+    // Well under the TTL: still idempotent, exactly like a legitimately long-lived active stream.
+    vi.advanceTimersByTime(60 * 60 * 1000); // +1h
+    await resolver.StartRemoteBrowserAudioStream('sess-crash-1', ctx, pubSub as never);
+    expect(liveSession.StartAudioStream).toHaveBeenCalledTimes(1);
+
+    // Past the TTL, with Stop NEVER called (simulating a crash/disconnect): the stale entry is swept,
+    // and a fresh Start is treated as a real (re)start rather than trusting the dead flag forever.
+    vi.advanceTimersByTime(5 * 60 * 60 * 1000); // +5h more (6h total, past the 4h TTL)
+    await resolver.StartRemoteBrowserAudioStream('sess-crash-1', ctx, pubSub as never);
+    expect(liveSession.StartAudioStream).toHaveBeenCalledTimes(2);
+  });
+
+  it('screencast: a crashed session (no Stop call) is forgotten after the TTL, so a later Start re-invokes StartScreencast', async () => {
+    const pubSub = makePubSub();
+    await resolver.StartRemoteBrowserScreencast('sess-crash-2', ctx, pubSub as never);
+    expect(liveSession.StartScreencast).toHaveBeenCalledTimes(1);
+
+    vi.advanceTimersByTime(6 * 60 * 60 * 1000); // 6h, past the 4h TTL
+    await resolver.StartRemoteBrowserScreencast('sess-crash-2', ctx, pubSub as never);
+    expect(liveSession.StartScreencast).toHaveBeenCalledTimes(2);
+  });
+
+  it('sweeping one stale surface does not evict an unrelated surface still inside the TTL', async () => {
+    const pubSub = makePubSub();
+    await resolver.StartRemoteBrowserAudioStream('sess-old', ctx, pubSub as never);
+
+    vi.advanceTimersByTime(3 * 60 * 60 * 1000); // +3h — sess-old is now 3h old, sess-new is fresh
+    await resolver.StartRemoteBrowserAudioStream('sess-new', ctx, pubSub as never);
+    expect(liveSession.StartAudioStream).toHaveBeenCalledTimes(2);
+
+    vi.advanceTimersByTime(2 * 60 * 60 * 1000); // +2h more — sess-old is 5h old (past TTL), sess-new is 2h old (within TTL)
+    // Triggering the sweep via a third session's Start must not evict sess-new's still-valid entry.
+    await resolver.StartRemoteBrowserAudioStream('sess-trigger', ctx, pubSub as never);
+    await resolver.StartRemoteBrowserAudioStream('sess-new', ctx, pubSub as never);
+    // sess-old, sess-new(first call), sess-trigger all real starts = 3 so far; the second sess-new
+    // call must still be idempotent (no 4th real start).
+    expect(liveSession.StartAudioStream).toHaveBeenCalledTimes(3);
+  });
+});