@memberjunction/server 5.49.0 → 5.51.0

package/src/__tests__/widgetGuestElevation.test.ts

@@ -1,6 +1,22 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
 import type { DatabaseProviderBase, UserInfo } from '@memberjunction/core';
-import { resolveWidgetGuestRunContext, elevateUserPayload } from '../realtimeWidget/widgetGuestElevation.js';
+
+// Controls what UserCache.Instance.GetSystemUser() serves — undefined simulates an unpopulated
+// cache (no system user available), the fail-closed path.
+const getSystemUserMock = vi.fn<[], UserInfo | undefined>();
+vi.mock('@memberjunction/sqlserver-dataprovider', () => ({
+  UserCache: {
+    get Instance() {
+      return { GetSystemUser: getSystemUserMock };
+    },
+  },
+}));
+
+import {
+  resolveWidgetGuestRunContext,
+  elevateUserPayload,
+  ResolveScopedAnonymousRunUser,
+} from '../realtimeWidget/widgetGuestElevation.js';
 import type { UserPayload } from '../types.js';
 
 /** A provider stub — the guard paths under test return before ever touching the provider. */
@@ -31,6 +47,58 @@ describe('widgetGuestElevation — resolveWidgetGuestRunContext (guard paths, no
   });
 });
 
+describe('widgetGuestElevation — ResolveScopedAnonymousRunUser (issue #3371)', () => {
+  const systemUser = { ID: 'system-1', Email: 'system@system.org' } as UserInfo;
+
+  /** Builds a UserInfo carrying the given per-session guest flags. */
+  function userWith(flags: Partial<UserInfo>): UserInfo {
+    return { ID: 'anon-1', Email: 'anonymous@magic-link.local', ...flags } as UserInfo;
+  }
+
+  beforeEach(() => {
+    getSystemUserMock.mockReset();
+    getSystemUserMock.mockReturnValue(systemUser);
+  });
+
+  it('returns the caller unchanged for a normal authenticated user', () => {
+    const named = userWith({ IsMagicLinkAnonymous: false, MagicLinkScope: { ResourceID: 'res-1' } });
+    expect(ResolveScopedAnonymousRunUser(named)).toBe(named);
+    expect(getSystemUserMock).not.toHaveBeenCalled();
+  });
+
+  it('returns the caller unchanged for an anonymous session with no resource scope', () => {
+    const unscoped = userWith({ IsMagicLinkAnonymous: true, MagicLinkScope: undefined });
+    expect(ResolveScopedAnonymousRunUser(unscoped)).toBe(unscoped);
+    expect(getSystemUserMock).not.toHaveBeenCalled();
+  });
+
+  it('returns the caller unchanged for a scoped anonymous session with an empty ResourceID', () => {
+    const emptyScope = userWith({ IsMagicLinkAnonymous: true, MagicLinkScope: { ResourceID: '' } });
+    expect(ResolveScopedAnonymousRunUser(emptyScope)).toBe(emptyScope);
+  });
+
+  it('returns the caller unchanged for a PUBLIC WEB-WIDGET guest (widget guests keep their own path)', () => {
+    const widgetGuest = userWith({
+      IsMagicLinkAnonymous: true,
+      MagicLinkScope: { ResourceID: 'res-1' },
+      WidgetGuestContext: { WidgetID: 'widget-1' },
+    });
+    expect(ResolveScopedAnonymousRunUser(widgetGuest)).toBe(widgetGuest);
+    expect(getSystemUserMock).not.toHaveBeenCalled();
+  });
+
+  it('FAILS CLOSED to the caller when no system user is available', () => {
+    getSystemUserMock.mockReturnValue(undefined);
+    const scopedAnon = userWith({ IsMagicLinkAnonymous: true, MagicLinkScope: { ResourceID: 'res-1' } });
+    expect(ResolveScopedAnonymousRunUser(scopedAnon)).toBe(scopedAnon);
+  });
+
+  it('returns the SYSTEM user for a scoped anonymous (non-widget) magic-link session', () => {
+    const scopedAnon = userWith({ IsMagicLinkAnonymous: true, MagicLinkScope: { ResourceID: 'res-1' } });
+    expect(ResolveScopedAnonymousRunUser(scopedAnon)).toBe(systemUser);
+  });
+});
+
 describe('widgetGuestElevation — elevateUserPayload', () => {
   it('swaps in the elevated principal while preserving the guest sessionId for PubSub routing', () => {
     const guestPayload = payloadWith({ IsMagicLinkAnonymous: true });

package/src/agentSessions/SessionManager.ts

@@ -8,6 +8,7 @@ import { AIAgentPermissionHelper } from '@memberjunction/ai-engine-base';
 import { RealtimeClientSessionService, RealtimeChannelServerHost } from '@memberjunction/ai-agents';
 import { GetHostInstanceID } from './HostInstance.js';
 import { writeReturningVisitorRecap } from './ReturningVisitorRecap.js';
+import { ResolveScopedAnonymousRunUser } from '../realtimeWidget/widgetGuestElevation.js';
 
 /** Entity names — centralised so the `MJ:`-prefix convention is applied in exactly one place. */
 const SESSION_ENTITY = 'MJ: AI Agent Sessions';
@@ -230,10 +231,14 @@ export class SessionManager {
             return;
         }
         try {
+            // SCOPED-ANONYMOUS ELEVATION (issue #3371): the runs were CREATED under the system user
+            // for a scoped anonymous session, so an owner-initiated (or error) close must finalize
+            // under it too — the caller's role holds no grants on the AI run entities. Janitor and
+            // shutdown sweeps already close as the system user and pass through unchanged.
             await new RealtimeClientSessionService().FinalizeCoAgentRun(
                 config.coAgentRunID ?? null,
                 config.promptRunID ?? null,
-                contextUser,
+                ResolveScopedAnonymousRunUser(contextUser),
                 provider,
                 true,
                 config.coAgentRunStepID ?? null,

package/src/auth/newUsers.ts

@@ -2,7 +2,7 @@ import { ApplicationInfo, DatabaseProviderBase, EntitySaveOptions, LogError, Log
 import { RegisterClass } from "@memberjunction/global";
 import { UserCache } from "@memberjunction/sqlserver-dataprovider";
 import { configInfo } from "../config.js";
-import { MJUserEntity, MJUserRoleEntity, MJUserApplicationEntity, MJUserApplicationEntityEntity, MJApplicationEntityType, MJApplicationEntityEntityType } from "@memberjunction/core-entities";
+import { MJUserEntity, MJUserRoleEntity, MJUserApplicationEntity, MJUserApplicationEntityEntity, MJApplicationEntityType, MJApplicationEntityEntityType, UserInfoEngine } from "@memberjunction/core-entities";
 
 export class NewUserBase {
     public async createNewUser(firstName: string, lastName: string, email: string, linkedRecordType: string = 'None', linkedEntityId?: string, linkedEntityRecordId?: string): Promise<MJUserEntity | null> {
@@ -90,10 +90,11 @@ export class NewUserBase {
                         }
                     } else {
                         LogStatus(`No UserApplications configured, using DefaultForNewUser applications for new user ${user.Name}`);
-                        applicationsToCreate = md.Applications
-                            .filter(a => a.DefaultForNewUser)
-                            .sort((a, b) => (a.DefaultSequence ?? 100) - (b.DefaultSequence ?? 100));
-                        LogStatus(`Found ${applicationsToCreate.length} applications with DefaultForNewUser=true`);
+                        // Bug F2: use the shared selector, which filters to Active apps flagged
+                        // DefaultForNewUser (in DefaultSequence order). This path previously omitted the
+                        // Status = 'Active' check, so an inactive default app could be provisioned here.
+                        applicationsToCreate = UserInfoEngine.GetDefaultApplicationsForNewUser(md);
+                        LogStatus(`Found ${applicationsToCreate.length} active applications with DefaultForNewUser=true`);
                     }
 
                     for (const [appIndex, application] of applicationsToCreate.entries()) {