@memberjunction/server 6.2.0-edge.1 → 6.2.0-edge.2

package/src/__tests__/orphanedConversationDetailReconciler.test.ts

@@ -0,0 +1,283 @@
+/**
+ * Conversation details left behind by a finished run must be closed (MJ #4222).
+ *
+ * `AgentRunner` closes the detail as the last step of a run, so a process that dies mid-run never
+ * gets there. The agent-run watchdog repairs the RUN but nothing repaired the detail — and the
+ * detail is the row the chat renders from. Observed directly: run B3E67FE3 force-failed by the
+ * watchdog while its detail stayed `In-Progress`, spinning for anyone who opened it.
+ *
+ * The properties that keep this safe to run unattended are pinned here: it never closes a message
+ * whose work is still going, and it never races the normal completion path.
+ */
+import 'reflect-metadata';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { RunViewParams, UserInfo } from '@memberjunction/core';
+
+const { mockRunView } = vi.hoisted(() => ({ mockRunView: vi.fn() }));
+
+const { mockGetEntityObject, writableStore } = vi.hoisted(() => ({
+    mockGetEntityObject: vi.fn(),
+    writableStore: { last: null as Record<string, unknown> | null },
+}));
+
+vi.mock('@memberjunction/global', () => ({
+    UUIDsEqual: (a: string, b: string) => String(a).toLowerCase() === String(b).toLowerCase(),
+}));
+
+vi.mock('@memberjunction/sqlserver-dataprovider', () => ({
+    UserCache: { Instance: { Users: [{ ID: 'OWNER-1', Email: 'owner@example.com' }] } },
+}));
+
+vi.mock('@memberjunction/core', () => {
+    class MockRunView {
+        public static FromMetadataProvider(): MockRunView {
+            return new MockRunView();
+        }
+        public async RunView(...args: unknown[]): Promise<unknown> {
+            return mockRunView(...args);
+        }
+    }
+    return { LogError: vi.fn(), LogStatus: vi.fn(), RunView: MockRunView };
+});
+
+import { ReconcileOrphanedConversationDetails, ORPHAN_DETAIL_GRACE_MS } from '../generic/OrphanedConversationDetailReconciler.js';
+
+const USER = { ID: 'U1' } as unknown as UserInfo;
+const CONVERSATION_ID = 'C1';
+
+/**
+ * Provider stub: hands back the entity the reconciler actually writes through, and quotes names the
+ * way the SQL Server provider does.
+ */
+const PROVIDER = {
+    GetEntityObject: mockGetEntityObject,
+    EntityByName: (name: string) =>
+        name === 'MJ: AI Agent Runs' ? { SchemaName: '__mj', BaseView: 'vwAIAgentRuns' } : undefined,
+    QuoteIdentifier: (name: string) => `[${name}]`,
+    QuoteSchemaAndView: (schema: string, view: string) => `[${schema}].[${view}]`,
+} as never;
+const DETAIL_ID = 'D1';
+
+function detail(over: Record<string, unknown> = {}) {
+    return { ID: DETAIL_ID, ConversationID: CONVERSATION_ID, Status: 'In-Progress', Message: '', ...over };
+}
+
+/**
+ * The record the reconciler loads and saves. Separate from the RunView projection on purpose: the
+ * reconciler deliberately does NOT write the entity RunView returned, because that one carries the
+ * system user and the conversation-detail permission gate refuses a non-owner.
+ */
+function writable(saveResult = true, loadedStatus = 'In-Progress') {
+    const w = {
+        ID: DETAIL_ID,
+        Status: loadedStatus,
+        Message: '',
+        Load: vi.fn(async () => true),
+        Save: vi.fn(async () => saveResult),
+        LatestResult: { CompleteMessage: 'denied' },
+    };
+    writableStore.last = w;
+    return w;
+}
+
+function script(details: unknown[], runs: unknown[], ownerId: string | null = 'OWNER-1', loadedStatus = 'In-Progress') {
+    mockRunView.mockImplementation(async (...args: unknown[]) => {
+        const params = args[0] as RunViewParams | undefined;
+        if (!params) throw new Error('RunView called with no params');
+        if (params.EntityName === 'MJ: Conversation Details') return { Success: true, Results: details };
+        if (params.EntityName === 'MJ: AI Agent Runs') return { Success: true, Results: runs };
+        if (params.EntityName === 'MJ: Conversations') {
+            return { Success: true, Results: ownerId ? [{ ID: CONVERSATION_ID, UserID: ownerId }] : [] };
+        }
+        throw new Error(`unexpected entity ${params.EntityName}`);
+    });
+    mockGetEntityObject.mockImplementation(async () => writable(true, loadedStatus));
+}
+
+const longAgo = () => new Date(Date.now() - ORPHAN_DETAIL_GRACE_MS - 60_000).toISOString();
+const justNow = () => new Date().toISOString();
+
+describe('ReconcileOrphanedConversationDetails', () => {
+    // Block body, NOT a concise arrow: `mockReset()` returns the mock, which is callable, and
+    // vitest treats a function returned from beforeEach as a teardown hook — so a concise arrow
+    // hands vitest the mock itself to invoke with no arguments after every test.
+    beforeEach(() => {
+        mockRunView.mockReset();
+        mockGetEntityObject.mockReset();
+        writableStore.last = null;
+    });
+
+    it('closes a detail whose run failed long ago', async () => {
+        const d = detail();
+        script([d], [{ ConversationDetailID: DETAIL_ID, Status: 'Failed', CompletedAt: longAgo(), ErrorMessage: 'watchdog force-fail' }]);
+
+        const closed = await ReconcileOrphanedConversationDetails(PROVIDER, USER);
+
+        expect(closed).toBe(1);
+        expect(writableStore.last?.Status).toBe('Error');
+        expect(writableStore.last?.Message).toBe('watchdog force-fail');
+    });
+
+    it('falls back to a failure marker only when the failed run carries no error text', async () => {
+        script([detail()], [{ ConversationDetailID: DETAIL_ID, Status: 'Failed', CompletedAt: longAgo() }]);
+
+        await ReconcileOrphanedConversationDetails(PROVIDER, USER);
+
+        expect(writableStore.last?.Status).toBe('Error');
+        expect(writableStore.last?.Message).toBe('❌ Failed');
+    });
+
+    it('marks a completed run as Complete, not Error', async () => {
+        const d = detail();
+        script([d], [{ ConversationDetailID: DETAIL_ID, Status: 'Completed', CompletedAt: longAgo() }]);
+
+        await ReconcileOrphanedConversationDetails(PROVIDER, USER);
+
+        expect(writableStore.last?.Status).toBe('Complete');
+        // A successful run has no error to report, so an empty message stays empty rather than
+        // carrying a failure marker that contradicts the status beside it.
+        expect(writableStore.last?.Message).toBe('');
+    });
+
+    it('marks a run that ended awaiting the user\'s reply as Complete', async () => {
+        // AwaitingFeedback is how a normal chat turn ends: the run succeeded and the agent's
+        // reply is the message. A process that dies before closing the detail leaves exactly
+        // this pair behind, and the stale-run sweep never touches it because it is not Running.
+        script([detail()], [{ ConversationDetailID: DETAIL_ID, Status: 'AwaitingFeedback', CompletedAt: longAgo() }]);
+
+        expect(await ReconcileOrphanedConversationDetails(PROVIDER, USER)).toBe(1);
+        expect(writableStore.last?.Status).toBe('Complete');
+        expect(writableStore.last?.Message).toBe('');
+    });
+
+    it('leaves a message alone while its run is parked on a workflow', async () => {
+        // Paused means a task graph is still executing on the run's behalf.
+        script([detail()], [{ ConversationDetailID: DETAIL_ID, Status: 'Paused', CompletedAt: null }]);
+
+        expect(await ReconcileOrphanedConversationDetails(PROVIDER, USER)).toBe(0);
+        expect(mockGetEntityObject).not.toHaveBeenCalled();
+    });
+
+    it('leaves a message alone while its run is still executing', async () => {
+        const d = detail();
+        script([d], [{ ConversationDetailID: DETAIL_ID, Status: 'Running', CompletedAt: null }]);
+
+        expect(await ReconcileOrphanedConversationDetails(PROVIDER, USER)).toBe(0);
+        expect(mockGetEntityObject).not.toHaveBeenCalled();
+    });
+
+    it('does not race the normal completion path inside the grace window', async () => {
+        const d = detail();
+        script([d], [{ ConversationDetailID: DETAIL_ID, Status: 'Completed', CompletedAt: justNow() }]);
+
+        expect(await ReconcileOrphanedConversationDetails(PROVIDER, USER)).toBe(0);
+        expect(mockGetEntityObject).not.toHaveBeenCalled();
+    });
+
+    it('leaves a message alone when no run exists yet', async () => {
+        const d = detail();
+        script([d], []);
+
+        expect(await ReconcileOrphanedConversationDetails(PROVIDER, USER)).toBe(0);
+        expect(mockGetEntityObject).not.toHaveBeenCalled();
+    });
+
+    it('judges a retried message on its newest attempt, not an older finished one', async () => {
+        const d = detail();
+        // DESC order: newest first. The newest attempt is still running.
+        script([d], [
+            { ConversationDetailID: DETAIL_ID, Status: 'Running', CompletedAt: null },
+            { ConversationDetailID: DETAIL_ID, Status: 'Failed', CompletedAt: longAgo() },
+        ]);
+
+        expect(await ReconcileOrphanedConversationDetails(PROVIDER, USER)).toBe(0);
+    });
+
+    it('preserves an existing message rather than overwriting the answer', async () => {
+        script([detail()], [{ ConversationDetailID: DETAIL_ID, Status: 'Completed', CompletedAt: longAgo() }]);
+        mockGetEntityObject.mockImplementation(async () => {
+            const w = writable();
+            w.Message = 'the real answer';
+            return w;
+        });
+
+        await ReconcileOrphanedConversationDetails(PROVIDER, USER);
+
+        // The loaded record already carries the answer; only the status should change.
+        expect(writableStore.last?.Message).toBe('the real answer');
+        expect(writableStore.last?.Status).toBe('Complete');
+    });
+
+    it('reports a refused save without throwing', async () => {
+        script([detail()], [{ ConversationDetailID: DETAIL_ID, Status: 'Failed', CompletedAt: longAgo() }]);
+        mockGetEntityObject.mockImplementation(async () => writable(false));
+
+        expect(await ReconcileOrphanedConversationDetails(PROVIDER, USER)).toBe(0);
+    });
+
+    it('writes as the conversation OWNER, never as the calling system user', async () => {
+        // REGRESSION, found only by running it against real data. The permission gate on
+        // MJ: Conversation Details refuses a non-owner and returns false with NO LatestResult, so
+        // every save was silently rejected while the reconciler reported success-shaped logs. The
+        // system user this pass runs as owns nothing, which is exactly who that gate stops.
+        script([detail()], [{ ConversationDetailID: DETAIL_ID, Status: 'Failed', CompletedAt: longAgo() }]);
+
+        await ReconcileOrphanedConversationDetails(PROVIDER, USER);
+
+        expect(mockGetEntityObject).toHaveBeenCalledWith(
+            'MJ: Conversation Details',
+            expect.objectContaining({ ID: 'OWNER-1' })
+        );
+    });
+
+    it('leaves the detail alone when no owner can be resolved', async () => {
+        script([detail()], [{ ConversationDetailID: DETAIL_ID, Status: 'Failed', CompletedAt: longAgo() }], null);
+
+        expect(await ReconcileOrphanedConversationDetails(PROVIDER, USER)).toBe(0);
+        expect(mockGetEntityObject).not.toHaveBeenCalled();
+    });
+
+    it('never throws out of a maintenance pass', async () => {
+        mockRunView.mockImplementation(async () => { throw new Error('db down'); });
+
+        await expect(ReconcileOrphanedConversationDetails(PROVIDER, USER)).resolves.toBe(0);
+    });
+
+    it('asks only for details that have a finished run, so stuck rows cannot fill the window', async () => {
+        // Details with no run, or with a run still executing, are never closed here. Read without
+        // this filter, 200 of them pin the oldest-first window and no closable orphan is reached.
+        script([detail()], [{ ConversationDetailID: DETAIL_ID, Status: 'Failed', CompletedAt: longAgo() }]);
+
+        await ReconcileOrphanedConversationDetails(PROVIDER, USER);
+
+        const detailCall = mockRunView.mock.calls.find(
+            c => (c[0] as RunViewParams).EntityName === 'MJ: Conversation Details'
+        );
+        expect((detailCall?.[0] as RunViewParams).ExtraFilter).toBe(
+            "Status = 'In-Progress' AND Role = 'AI' AND ID IN (SELECT [ConversationDetailID] FROM [__mj].[vwAIAgentRuns] " +
+            "WHERE [Status] IN ('Completed','AwaitingFeedback','Failed','Cancelled'))"
+        );
+    });
+
+    it('leaves a detail alone when something else closed it after the list query', async () => {
+        // The normal completion path can close the row between our read and our write. Writing
+        // anyway would stamp this pass's outcome over the one that actually happened.
+        script(
+            [detail()],
+            [{ ConversationDetailID: DETAIL_ID, Status: 'Failed', CompletedAt: longAgo(), ErrorMessage: 'late' }],
+            'OWNER-1',
+            'Complete'
+        );
+
+        const closed = await ReconcileOrphanedConversationDetails(PROVIDER, USER);
+
+        expect(closed).toBe(0);
+        expect(writableStore.last?.Status).toBe('Complete');
+        expect((writableStore.last?.Save as ReturnType<typeof vi.fn>)).not.toHaveBeenCalled();
+    });
+
+    it('does nothing when no message is in progress', async () => {
+        script([], []);
+        expect(await ReconcileOrphanedConversationDetails(PROVIDER, USER)).toBe(0);
+    });
+});

package/src/__tests__/pushStatusFanOut.test.ts

@@ -0,0 +1,206 @@
+/**
+ * Tests for cross-instance fan-out of push-status updates (MJ #4222).
+ *
+ * Behind a load balancer the browser's WebSocket lives on one replica while the mutation driving
+ * the agent may be handled by another, so a completion can be published to a topic that has no
+ * subscriber. Replicating progress and completion closes that.
+ *
+ * Three properties are pinned here because each one, if wrong, produces a bug that looks like
+ * something else entirely:
+ *
+ * - **Streaming content is not replicated.** It is hundreds of messages per second, each carrying
+ *   a full serialized agent run. Replicating it would look like a network problem, not a bug here.
+ * - **Every publish carries `SourceServerId`.** Without it, echo suppression on the receiving side
+ *   has nothing to match and every push is delivered twice.
+ * - **A hook that throws does not break local delivery.** The message bus is an optimization over
+ *   the durable tail query; the local path must work when it is down.
+ */
+import 'reflect-metadata';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+    publishStatusUpdate,
+    ParseReplicatedStatusUpdate,
+    ShouldReplicateStatusUpdate,
+    SetPushStatusPublishHook,
+    type PushStatusNotificationPayload,
+} from '../generic/PushStatusResolver.js';
+import { MJGlobal } from '@memberjunction/global';
+import type { PubSubEngine } from 'type-graphql';
+
+const SESSION = 'session-1';
+const OWNER = 'U0000000-0000-0000-0000-000000000000';
+
+function fakePubSub() {
+    const published: Array<{ topic: string; payload: PushStatusNotificationPayload }> = [];
+    const engine = {
+        publish: (topic: string, payload: PushStatusNotificationPayload) => {
+            published.push({ topic, payload });
+            return Promise.resolve();
+        },
+    } as unknown as PubSubEngine;
+    return { engine, published };
+}
+
+const envelope = (type: string) => JSON.stringify({ resolver: 'RunAIAgentResolver', type, status: 'ok', data: {} });
+
+afterEach(() => {
+    SetPushStatusPublishHook(undefined);
+});
+
+describe('ShouldReplicateStatusUpdate', () => {
+    it('replicates execution progress', () => {
+        expect(ShouldReplicateStatusUpdate(envelope('ExecutionProgress'))).toBe(true);
+    });
+
+    it('does not replicate streaming content', () => {
+        expect(ShouldReplicateStatusUpdate(envelope('StreamingContent'))).toBe(false);
+    });
+
+    it('replicates a plain-string message, which is rare and low-rate', () => {
+        expect(ShouldReplicateStatusUpdate('agent finished')).toBe(true);
+    });
+
+    it('does not replicate an empty message', () => {
+        expect(ShouldReplicateStatusUpdate(undefined)).toBe(false);
+        expect(ShouldReplicateStatusUpdate('')).toBe(false);
+    });
+
+    it('replicates JSON that is not the resolver envelope', () => {
+        expect(ShouldReplicateStatusUpdate(JSON.stringify({ hello: 'world' }))).toBe(true);
+    });
+});
+
+describe('publishStatusUpdate fan-out', () => {
+    beforeEach(() => {
+        SetPushStatusPublishHook(undefined);
+    });
+
+    it('stamps the publishing instance on every payload', () => {
+        const { engine, published } = fakePubSub();
+
+        publishStatusUpdate(engine, { sessionId: SESSION, ownerUserId: OWNER, message: envelope('ExecutionProgress') });
+
+        expect(published).toHaveLength(1);
+        expect(published[0].payload.SourceServerId).toBe(MJGlobal.Instance.ProcessUUID);
+    });
+
+    it('still publishes locally when no hook is registered', () => {
+        const { engine, published } = fakePubSub();
+
+        publishStatusUpdate(engine, { sessionId: SESSION, ownerUserId: OWNER, message: envelope('ExecutionProgress') });
+
+        expect(published[0].payload.ownerUserId).toBe(OWNER);
+    });
+
+    it('forwards a replicable update to the hook', () => {
+        const hook = vi.fn();
+        SetPushStatusPublishHook(hook);
+        const { engine } = fakePubSub();
+
+        publishStatusUpdate(engine, { sessionId: SESSION, ownerUserId: OWNER, message: envelope('ExecutionProgress') });
+
+        expect(hook).toHaveBeenCalledTimes(1);
+        const forwarded = hook.mock.calls[0][0] as PushStatusNotificationPayload;
+        expect(forwarded.sessionId).toBe(SESSION);
+        expect(forwarded.ownerUserId).toBe(OWNER);
+        expect(forwarded.SourceServerId).toBe(MJGlobal.Instance.ProcessUUID);
+    });
+
+    it('does not forward streaming content, but still delivers it locally', () => {
+        const hook = vi.fn();
+        SetPushStatusPublishHook(hook);
+        const { engine, published } = fakePubSub();
+
+        publishStatusUpdate(engine, { sessionId: SESSION, ownerUserId: OWNER, message: envelope('StreamingContent') });
+
+        expect(hook).not.toHaveBeenCalled();
+        expect(published).toHaveLength(1);
+    });
+
+    it('delivers locally even when the hook throws', () => {
+        SetPushStatusPublishHook(() => {
+            throw new Error('redis is down');
+        });
+        const { engine, published } = fakePubSub();
+
+        expect(() =>
+            publishStatusUpdate(engine, { sessionId: SESSION, ownerUserId: OWNER, message: envelope('ExecutionProgress') })
+        ).not.toThrow();
+        expect(published).toHaveLength(1);
+    });
+
+    it('publishes locally before attempting fan-out', () => {
+        const order: string[] = [];
+        SetPushStatusPublishHook(() => order.push('hook'));
+        const engine = {
+            publish: () => {
+                order.push('local');
+                return Promise.resolve();
+            },
+        } as unknown as PubSubEngine;
+
+        publishStatusUpdate(engine, { sessionId: SESSION, ownerUserId: OWNER, message: envelope('ExecutionProgress') });
+
+        expect(order).toEqual(['local', 'hook']);
+    });
+
+    it('clears the hook when set with no argument', () => {
+        const hook = vi.fn();
+        SetPushStatusPublishHook(hook);
+        SetPushStatusPublishHook(undefined);
+        const { engine } = fakePubSub();
+
+        publishStatusUpdate(engine, { sessionId: SESSION, ownerUserId: OWNER, message: envelope('ExecutionProgress') });
+
+        expect(hook).not.toHaveBeenCalled();
+    });
+});
+
+describe('ParseReplicatedStatusUpdate', () => {
+    /**
+     * Messages on the shared channel come from other processes, so every field is checked before
+     * the update is republished onto the local topic, where the subscription filter compares
+     * `ownerUserId` against the connection's user.
+     */
+    const LOCAL = 'LOCAL-PROCESS';
+    const raw = (over: Record<string, unknown> = {}) =>
+        JSON.stringify({ sessionId: SESSION, ownerUserId: OWNER, message: 'hello', SourceServerId: 'OTHER', ...over });
+
+    it('returns the update from another instance', () => {
+        expect(ParseReplicatedStatusUpdate(raw(), LOCAL)).toEqual({
+            sessionId: SESSION,
+            ownerUserId: OWNER,
+            message: 'hello',
+            SourceServerId: 'OTHER',
+        });
+    });
+
+    it('drops our own message echoed back by the bus', () => {
+        expect(ParseReplicatedStatusUpdate(raw({ SourceServerId: LOCAL }), LOCAL)).toBeNull();
+    });
+
+    it('drops an update with no identity', () => {
+        expect(ParseReplicatedStatusUpdate(raw({ ownerUserId: '' }), LOCAL)).toBeNull();
+        expect(ParseReplicatedStatusUpdate(raw({ sessionId: undefined }), LOCAL)).toBeNull();
+    });
+
+    it('drops identity fields that are not strings', () => {
+        // A truthy object would pass a presence check and reach the filter as the wrong type.
+        expect(ParseReplicatedStatusUpdate(raw({ ownerUserId: { ID: OWNER } }), LOCAL)).toBeNull();
+        expect(ParseReplicatedStatusUpdate(raw({ sessionId: 42 }), LOCAL)).toBeNull();
+    });
+
+    it('drops a message body that is not a string', () => {
+        expect(ParseReplicatedStatusUpdate(raw({ message: { type: 'x' } }), LOCAL)).toBeNull();
+    });
+
+    it('accepts an update with no message body', () => {
+        expect(ParseReplicatedStatusUpdate(raw({ message: undefined }), LOCAL)?.message).toBeUndefined();
+    });
+
+    it('drops malformed JSON and values that are not objects', () => {
+        expect(ParseReplicatedStatusUpdate('{not json', LOCAL)).toBeNull();
+        expect(ParseReplicatedStatusUpdate('null', LOCAL)).toBeNull();
+        expect(ParseReplicatedStatusUpdate('42', LOCAL)).toBeNull();
+    });
+});

package/src/auth/__tests__/backward-compatibility.test.ts

@@ -21,6 +21,7 @@ describe('Authentication Provider Backward Compatibility', () => {
   let factory: AuthProviderFactory;
   
   beforeEach(() => {
+    vi.spyOn(AuthProviderFactory, 'DiscoverFromEnvironment').mockReturnValue([]);
     factory = AuthProviderFactory.Instance;
     factory.clear();
   });