@memberjunction/server 6.2.0-edge.6 → 6.2.0-edge.8

package/src/resolvers/SqlLoggingConfigResolver.ts

@@ -9,6 +9,7 @@ import { LoadConfig } from '../config.js';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { GetReadOnlyProvider } from '../util.js';
 import { UserCache, SqlLoggingOptions as ProviderSqlLoggingOptions } from '@memberjunction/generic-database-provider';
+import { IsScopeLimitedPrincipal } from '../auth/scopeLimitedPrincipal.js';
 
 /**
  * Configuration options for SQL logging sessions.
@@ -252,6 +253,9 @@ export class SqlLoggingConfigResolver extends ResolverBase {
    * @private
    */
   private async checkOwnerAccess(context: AppContext): Promise<UserInfo> {
+    if (context?.userPayload?.userRecord && IsScopeLimitedPrincipal(context.userPayload.userRecord)) {
+      throw new Error('Access denied. Scope-limited principals cannot access SQL logging.');
+    }
     const userEmail = context.userPayload?.email;
     if (!userEmail) {
       throw new Error('User not authenticated');
@@ -263,15 +267,9 @@ export class SqlLoggingConfigResolver extends ResolverBase {
     if (!user) {
       throw new Error('User not found');
     }
-    
-    // Debug logging
-    console.log('SQL Logging access check:', {
-      email: user.Email,
-      type: user.Type,
-      typeLength: user.Type?.length,
-      typeTrimmed: user.Type?.trim(),
-      isOwner: user.Type?.trim().toLowerCase() === 'owner'
-    });
+    if (IsScopeLimitedPrincipal(user)) {
+      throw new Error('Access denied. Scope-limited principals cannot access SQL logging.');
+    }
     
     // Check if user has Type = 'Owner' (trim and case-insensitive for nchar fields)
     if (user.Type?.trim().toLowerCase() !== 'owner') {

package/src/resolvers/TagGovernanceResolver.ts

@@ -3,6 +3,7 @@ import { AppContext } from '../types.js';
 import { LogError, LogStatus } from '@memberjunction/core';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { TagGovernanceEngine, TagHealthJob, DEFAULT_TAG_HEALTH_THRESHOLDS, TagEngine } from '@memberjunction/tag-engine';
+import { TagCoOccurrenceEngine } from '@memberjunction/tag-engine-base';
 
 @ObjectType()
 export class PromoteSuggestionResult {
@@ -28,6 +29,30 @@ export class RejectSuggestionResult {
     ErrorMessage?: string;
 }
 
+@ObjectType()
+export class MergeTagsResult {
+    @Field()
+    Success: boolean;
+
+    @Field(() => Int)
+    ItemsMoved: number;
+
+    @Field(() => Int)
+    TaggedItemsMoved: number;
+
+    @Field({ nullable: true })
+    ErrorMessage?: string;
+}
+
+@ObjectType()
+export class RecomputeTagCoOccurrenceResult {
+    @Field(() => Int)
+    PairsUpdated: number;
+
+    @Field(() => Int)
+    PairsDeleted: number;
+}
+
 @ObjectType()
 export class RebuildTagEmbeddingsResult {
     @Field()
@@ -186,4 +211,44 @@ export class TagGovernanceResolver extends ResolverBase {
             return { Success: false, MergeCount: 0, LowUsageCount: 0, WideNodeCount: 0, DurationMs: 0, ErrorMessage: msg };
         }
     }
+
+    @Mutation(() => MergeTagsResult)
+    async MergeTags(
+        @Arg('sourceTagIDs', () => [String]) sourceTagIDs: string[],
+        @Arg('survivingTagID') survivingTagID: string,
+        @Ctx() { userPayload }: AppContext = {} as AppContext
+    ): Promise<MergeTagsResult> {
+        try {
+            const currentUser = this.GetUserFromPayload(userPayload);
+            if (!currentUser) {
+                return { Success: false, ItemsMoved: 0, TaggedItemsMoved: 0, ErrorMessage: 'Unable to determine current user' };
+            }
+            await TagEngine.Instance.Config(false, currentUser);
+            const result = await TagGovernanceEngine.Instance.MergeTags(sourceTagIDs, survivingTagID, currentUser);
+            return {
+                Success: true,
+                ItemsMoved: result.ItemsMoved,
+                TaggedItemsMoved: result.TaggedItemsMoved,
+            };
+        } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            LogError(`MergeTags failed for survivingTagID ${survivingTagID}: ${msg}`);
+            return { Success: false, ItemsMoved: 0, TaggedItemsMoved: 0, ErrorMessage: msg };
+        }
+    }
+
+    @Mutation(() => RecomputeTagCoOccurrenceResult)
+    async RecomputeTagCoOccurrence(
+        @Ctx() { userPayload }: AppContext = {} as AppContext
+    ): Promise<RecomputeTagCoOccurrenceResult> {
+        const currentUser = this.GetUserFromPayload(userPayload);
+        if (!currentUser) {
+            throw new Error('Unable to determine current user');
+        }
+        const result = await TagCoOccurrenceEngine.Instance.RecomputeCoOccurrence(currentUser);
+        return {
+            PairsUpdated: result.PairsUpdated,
+            PairsDeleted: result.PairsDeleted,
+        };
+    }
 }

package/src/resolvers/TelemetryResolver.ts

@@ -3,8 +3,11 @@ import { AppContext } from '../types.js';
 import {
     TelemetryManager,
     TelemetryCategory,
-    TelemetryInsightSeverity
+    TelemetryInsightSeverity,
+    AuthorizationEvaluator,
 } from '@memberjunction/core';
+import { IsScopeLimitedPrincipal } from '../auth/scopeLimitedPrincipal.js';
+import { GetReadOnlyProvider } from '../util.js';
 
 // ============================================================================
 // GraphQL Types for TelemetryEvent
@@ -318,12 +321,38 @@ export class TelemetryInsightFilterInput {
 
 @Resolver()
 export class TelemetryResolver {
+    /**
+     * Enforces that the caller is an authenticated, non-scope-limited user who holds either
+     * Owner privileges or the `'Diagnostics: Run Sessions'` authorization.
+     */
+    private requireDiagnosticsAccess(context: AppContext): void {
+        const user = context?.userPayload?.userRecord;
+        if (!user || IsScopeLimitedPrincipal(user)) {
+            throw new Error('Access denied: server telemetry requires an authenticated non-scope-limited user.');
+        }
+        if (user.Type?.trim().toLowerCase() === 'owner') {
+            return;
+        }
+        const authorizations = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true })?.Authorizations ?? [];
+        const diagAuth = authorizations.find(
+            (a) => a.Name?.trim().toLowerCase() === 'diagnostics: run sessions'
+        );
+        if (diagAuth) {
+            const evaluator = new AuthorizationEvaluator();
+            if (evaluator.UserCanExecuteWithAncestors(diagAuth, user, authorizations)) {
+                return;
+            }
+        }
+        throw new Error('Access denied: server telemetry requires Owner privileges or the "Diagnostics: Run Sessions" authorization.');
+    }
+
     /**
      * Get telemetry settings
-     * Accessible to any authenticated user - telemetry data is not sensitive
+     * Requires Owner privileges or 'Diagnostics: Run Sessions' authorization
      */
     @Query(() => TelemetrySettingsGQL)
-    GetServerTelemetrySettings(@Ctx() _context: AppContext): TelemetrySettingsGQL {
+    GetServerTelemetrySettings(@Ctx() context: AppContext): TelemetrySettingsGQL {
+        this.requireDiagnosticsAccess(context);
         const tm = TelemetryManager.Instance;
         const settings = tm.Settings;
 
@@ -365,7 +394,8 @@ export class TelemetryResolver {
      * Get telemetry statistics
      */
     @Query(() => TelemetryStatsGQL)
-    GetServerTelemetryStats(@Ctx() _context: AppContext): TelemetryStatsGQL {
+    GetServerTelemetryStats(@Ctx() context: AppContext): TelemetryStatsGQL {
+        this.requireDiagnosticsAccess(context);
         const tm = TelemetryManager.Instance;
         const stats = tm.GetStats();
 
@@ -391,9 +421,10 @@ export class TelemetryResolver {
      */
     @Query(() => [TelemetryEventGQL])
     GetServerTelemetryEvents(
-        @Ctx() _context: AppContext,
+        @Ctx() context: AppContext,
         @Arg('filter', () => TelemetryEventFilterInput, { nullable: true }) filter?: TelemetryEventFilterInput
     ): TelemetryEventGQL[] {
+        this.requireDiagnosticsAccess(context);
         const tm = TelemetryManager.Instance;
 
         const events = tm.GetEvents({
@@ -427,9 +458,10 @@ export class TelemetryResolver {
      */
     @Query(() => [TelemetryPatternGQL])
     GetServerTelemetryPatterns(
-        @Ctx() _context: AppContext,
+        @Ctx() context: AppContext,
         @Arg('filter', () => TelemetryPatternFilterInput, { nullable: true }) filter?: TelemetryPatternFilterInput
     ): TelemetryPatternGQL[] {
+        this.requireDiagnosticsAccess(context);
         const tm = TelemetryManager.Instance;
 
         const patterns = tm.GetPatterns({
@@ -468,9 +500,10 @@ export class TelemetryResolver {
      */
     @Query(() => [TelemetryInsightGQL])
     GetServerTelemetryInsights(
-        @Ctx() _context: AppContext,
+        @Ctx() context: AppContext,
         @Arg('filter', () => TelemetryInsightFilterInput, { nullable: true }) filter?: TelemetryInsightFilterInput
     ): TelemetryInsightGQL[] {
+        this.requireDiagnosticsAccess(context);
         const tm = TelemetryManager.Instance;
 
         const insights = tm.GetInsights({
@@ -500,9 +533,10 @@ export class TelemetryResolver {
      */
     @Query(() => [TelemetryPatternGQL])
     GetServerTelemetryDuplicates(
-        @Ctx() _context: AppContext,
+        @Ctx() context: AppContext,
         @Arg('minCount', () => Int, { defaultValue: 2 }) minCount: number
     ): TelemetryPatternGQL[] {
+        this.requireDiagnosticsAccess(context);
         const tm = TelemetryManager.Instance;
         const patterns = tm.GetDuplicates(minCount);
 
@@ -534,7 +568,8 @@ export class TelemetryResolver {
      * Get currently active (in-progress) events
      */
     @Query(() => [TelemetryEventGQL])
-    GetServerTelemetryActiveEvents(@Ctx() _context: AppContext): TelemetryEventGQL[] {
+    GetServerTelemetryActiveEvents(@Ctx() context: AppContext): TelemetryEventGQL[] {
+        this.requireDiagnosticsAccess(context);
         const tm = TelemetryManager.Instance;
         const events = tm.GetActiveEvents();
 

package/src/resolvers/__tests__/GetDataResolver.tokens.test.ts

@@ -23,6 +23,8 @@ vi.mock('../../auth/index.js', () => ({ GetSystemUser: vi.fn(),
 vi.mock('mssql', () => ({ default: { Request: vi.fn() } }));
 
 import {
+  GetDataResolver,
+  GetDataInputType,
   RegisterAccessToken,
   DeleteAccessToken,
   TokenExists,
@@ -31,6 +33,7 @@ import {
   PruneExpiredTokens,
   GetAccessTokenCount,
 } from '../GetDataResolver.js';
+import type { AppContext } from '../../types.js';
 
 // ---------------------------------------------------------------------------
 // Regression coverage for a memory leak (Memory Leak Audit Round 7, Critical):
@@ -137,4 +140,53 @@ describe('GetDataResolver access-token lifecycle', () => {
     expect(GetAccessTokenCount()).toBeLessThan(before + 51);
     expect(TokenExists(survivorToken)).toBe(true);
   });
+
+  it('never leaks raw secret token values in thrown or returned error messages', async () => {
+    const duplicateSecret = `secret-dup-${uniqueToken()}`;
+    RegisterAccessToken(duplicateSecret, 60_000);
+
+    try {
+      RegisterAccessToken(duplicateSecret, 60_000);
+      expect.unreachable('Expected duplicate registration to throw');
+    } catch (err) {
+      expect((err as Error).message).not.toContain(duplicateSecret);
+    }
+
+    const missingSecret = `secret-missing-${uniqueToken()}`;
+    try {
+      DeleteAccessToken(missingSecret);
+      expect.unreachable('Expected deleting unknown token to throw');
+    } catch (err) {
+      expect((err as Error).message).not.toContain(missingSecret);
+    }
+
+    try {
+      RecordTokenUse(missingSecret, {});
+      expect.unreachable('Expected recording unknown token use to throw');
+    } catch (err) {
+      expect((err as Error).message).not.toContain(missingSecret);
+    }
+
+    const resolver = new GetDataResolver();
+    const input = new GetDataInputType();
+    input.Token = missingSecret;
+    input.Queries = ['SELECT 1'];
+    const output = await resolver.GetData(input, { dataSources: [] } as Partial<AppContext> as AppContext);
+    expect(output.Success).toBe(false);
+    expect(JSON.stringify(output.ErrorMessages)).not.toContain(missingSecret);
+  });
+
+  it('rejects empty tokens and near-miss prefix tokens across multiple active slots', () => {
+    const first = `slot-a-${uniqueToken()}`;
+    const second = `slot-b-${uniqueToken()}`;
+    RegisterAccessToken(first, 60_000);
+    RegisterAccessToken(second, 60_000);
+
+    expect(IsTokenValid('')).toBe(false);
+    expect(TokenExists('')).toBe(false);
+    expect(IsTokenValid(first.slice(0, -1))).toBe(false);
+    expect(IsTokenValid(`${second}-extra`)).toBe(false);
+    expect(IsTokenValid(first)).toBe(true);
+    expect(IsTokenValid(second)).toBe(true);
+  });
 });

package/src/resolvers/meetingRecordingRegistration.ts

@@ -268,6 +268,7 @@ async function findConversationByEgressID(egressID: string, contextUser: UserInf
       Fields: ['ID'],
       OrderBy: '__mj_CreatedAt DESC',
       MaxRows: 1,
+      SkipTotalRowCount: true,
       ResultType: 'simple',
     },
     contextUser,
@@ -288,6 +289,7 @@ async function findConversationByRoomName(roomName: string, contextUser: UserInf
       Fields: ['ID'],
       OrderBy: '__mj_CreatedAt DESC',
       MaxRows: 1,
+      SkipTotalRowCount: true,
       ResultType: 'simple',
     },
     contextUser,

package/src/resolvers/meetings/meetingMutations.ts

@@ -5,7 +5,7 @@ import {
   RunView,
   UserInfo,
 } from '@memberjunction/core';
-import { EscapeSQLString, UUIDsEqual } from '@memberjunction/global';
+import { EscapeSQLString, IndexByUUID, UUIDsEqual } from '@memberjunction/global';
 import type {
   MJMeetingEntity,
   MJMeetingParticipantEntity,
@@ -25,6 +25,7 @@ import {
   UpdateMeetingInput,
   RSVPMeetingInput,
   MeetingParticipantType,
+  MeetingParticipantInput,
 } from './meetingTypes.js';
 import * as defaultHelpers from './meetingHelpers.js';
 
@@ -34,6 +35,39 @@ function resolveHelpers(overrides?: Partial<MeetingHelpers>): MeetingHelpers {
   return { ...defaultHelpers, ...overrides };
 }
 
+/**
+ * Indexes a meeting's participants by UserID, AgentID and lower-cased ExternalEmail, and returns a
+ * lookup that finds the participant an update input refers to. When the input matches different
+ * participants on different keys, the one listed first in `existing` wins, as a single
+ * `existing.find` over all three keys would answer.
+ */
+function indexParticipants(
+  existing: MeetingParticipantType[],
+): (input: MeetingParticipantInput) => MeetingParticipantType | undefined {
+  const byUserID = IndexByUUID(existing.filter((e) => e.UserID), (e) => e.UserID);
+  const byAgentID = IndexByUUID(existing.filter((e) => e.AgentID), (e) => e.AgentID);
+  const byEmail = new Map<string, MeetingParticipantType>();
+  const position = new Map<MeetingParticipantType, number>();
+  existing.forEach((e, i) => {
+    position.set(e, i);
+    const email = e.ExternalEmail?.toLowerCase();
+    if (email && !byEmail.has(email)) byEmail.set(email, e);
+  });
+
+  return (input) => {
+    const candidates = [
+      input.UserID ? byUserID.Get(input.UserID) : undefined,
+      input.AgentID ? byAgentID.Get(input.AgentID) : undefined,
+      input.ExternalEmail ? byEmail.get(input.ExternalEmail.toLowerCase()) : undefined,
+    ];
+    let first: MeetingParticipantType | undefined;
+    for (const candidate of candidates) {
+      if (candidate && (!first || (position.get(candidate) ?? 0) < (position.get(first) ?? 0))) first = candidate;
+    }
+    return first;
+  };
+}
+
 export async function ExecuteCreateMeeting(
   provider: IMetadataProvider,
   user: UserInfo,
@@ -235,15 +269,11 @@ export async function ExecuteUpdateMeeting(
     // If participants specified in update, sync participants (upsert by UserID/AgentID/ExternalEmail)
     if (input.Participants !== undefined) {
       const existing = await h.LoadParticipants(meeting.ID, user, provider);
+      const findExisting = indexParticipants(existing);
 
       for (const pInput of input.Participants) {
         const isSelf = pInput.UserID && UUIDsEqual(pInput.UserID, user.ID);
-        const match = existing.find(
-          (e) =>
-            (pInput.UserID && e.UserID && UUIDsEqual(e.UserID, pInput.UserID)) ||
-            (pInput.AgentID && e.AgentID && UUIDsEqual(e.AgentID, pInput.AgentID)) ||
-            (pInput.ExternalEmail && e.ExternalEmail && e.ExternalEmail.toLowerCase() === pInput.ExternalEmail.toLowerCase()),
-        );
+        const match = findExisting(pInput);
 
         if (match) {
           if (!isSelf && pInput.Role) {

package/src/rest/MediaAccessKeys.ts

@@ -18,7 +18,7 @@
 
 import { BaseSingleton } from '@memberjunction/global';
 import { LogStatus } from '@memberjunction/core';
-import { randomBytes } from 'node:crypto';
+import { createHmac, randomBytes } from 'node:crypto';
 import jwt from 'jsonwebtoken';
 
 /** The token's `typ` claim — the route rejects any token whose `typ` differs. */
@@ -78,7 +78,11 @@ export class MediaAccessKeyManager extends BaseSingleton<MediaAccessKeyManager>
     }
     const configured = process.env.MJ_BASE_ENCRYPTION_KEY?.trim();
     if (configured) {
-      this.secret = configured;
+      // Key separation: never sign tokens with the field-encryption master key itself. Derive a
+      // dedicated HS256 signing key (HKDF-style HMAC expand) so a token-signing compromise and the
+      // data-at-rest key stay decoupled. Tokens are short-lived, so changing the derivation only
+      // invalidates in-flight URLs, exactly like a restart on the ephemeral path below.
+      this.secret = createHmac('sha256', configured).update('mj-media-access-token-signing-v1').digest('base64');
     } else {
       this.secret = randomBytes(32).toString('base64');
       LogStatus(

package/src/rest/OAuthCallbackHandler.ts

@@ -28,6 +28,15 @@ const ENTITY_MCP_SERVERS = 'MJ: MCP Servers';
 /** Entity name for OAuth Authorization States */
 const ENTITY_OAUTH_AUTHORIZATION_STATES = 'MJ: O Auth Authorization States';
 
+const UUID_SHAPE = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+
+function sqlUuid(value: string, argName: string): string {
+    if (typeof value !== 'string' || !UUID_SHAPE.test(value)) {
+        throw new Error(`${argName} must be a UUID`);
+    }
+    return value;
+}
+
 /**
  * Configuration for OAuth callback handler
  */
@@ -693,12 +702,11 @@ export class OAuthCallbackHandler {
             const rv = new RunView();
 
             // Get connection to get server ID.
-            // connectionId is caller-supplied (POST /oauth/initiate body). MJ ExtraFilter is a raw
-            // SQL fragment, so single quotes MUST be doubled to prevent injection — matching the
-            // escaping used for stateParameter in loadAuthorizationState().
+            // connectionId is caller-supplied (POST /oauth/initiate body); enforce strict UUID shape
+            // (matching MCPResolver.getServerOAuthConfig) before interpolating into ExtraFilter.
             const connResult = await rv.RunView<{ MCPServerID: string }>({
                 EntityName: ENTITY_MCP_SERVER_CONNECTIONS,
-                ExtraFilter: `ID='${connectionId.replace(/'/g, "''")}'`,
+                ExtraFilter: `ID='${sqlUuid(connectionId, 'connectionId')}'`,
                 Fields: ['MCPServerID'],
                 ResultType: 'simple'
             }, contextUser);
@@ -719,7 +727,7 @@ export class OAuthCallbackHandler {
                 OAuthRequirePKCE: boolean | null;
             }>({
                 EntityName: ENTITY_MCP_SERVERS,
-                ExtraFilter: `ID='${serverId}'`,
+                ExtraFilter: `ID='${sqlUuid(serverId, 'serverId')}'`,
                 Fields: [
                     'OAuthIssuerURL', 'OAuthScopes', 'OAuthMetadataCacheTTLMinutes',
                     'OAuthClientID', 'OAuthClientSecretEncrypted', 'OAuthRequirePKCE'

package/src/rest/RealtimeRecordingHandler.ts

@@ -34,7 +34,7 @@ import {
     LoadOwnedRealtimeSession, RealtimeSessionNotFoundError, RealtimeSessionOwnershipError,
 } from '../realtimeSessions/ownedRealtimeSession.js';
 import type { IRecordingAssemblyScheduler } from '../realtimeSessions/RecordingAssemblyScheduler.js';
-import { AuthorizeSessionAccess, LoadSessionConversationScope } from '../realtimeSessions/sessionAccess.js';
+import { AuthorizeLoadedSession } from '../realtimeSessions/sessionAccess.js';
 
 /** Where {@link CreateRealtimeRecordingRouter} is mounted (under the reserved `/realtime` root). */
 export const REALTIME_RECORDING_MOUNT_PATH = '/realtime/recording';
@@ -76,8 +76,8 @@ export interface RealtimeRecordingRouterDeps {
     /** The authenticated caller, or null (answered 401). */
     ResolveCaller(req: Request): RealtimeRecordingCaller | null;
     LoadOwnedSession: typeof LoadOwnedRealtimeSession;
-    /** The session conversation's scope id and whether the caller could read it: the scope half of the access decision. */
-    LoadConversationScope: typeof LoadSessionConversationScope;
+    /** The per-session scope rule of the access decision, applied to the session {@link LoadOwnedSession} returned. */
+    AuthorizeSession: typeof AuthorizeLoadedSession;
     /** The ledger for one request; `contextUser` is the caller (used for logging by the procs). */
     CreateLedger(provider: DatabaseProviderBase, contextUser: UserInfo): IRealtimeRecordingLedger;
     Scheduler: IRecordingAssemblyScheduler;
@@ -258,7 +258,7 @@ async function handleTerminal(deps: RealtimeRecordingRouterDeps, req: Request, r
 
 /**
  * Loads the session through the shared ownership gate, then applies the per-session scope rule of
- * {@link AuthorizeSessionAccess}. The production gate (`LoadOwnedRealtimeSession`) already applies the same
+ * {@link AuthorizeLoadedSession}. The production gate (`LoadOwnedRealtimeSession`) already applies the same
  * rule, so this is a deliberate second check at the HTTP boundary: `LoadOwnedSession` is an injected dependency,
  * and without the scope rule one anonymous guest could write shards to another guest's recording (every guest
  * shares the one Anonymous user), and a different-bytes shard would mark it Failed. It costs one extra
@@ -266,11 +266,7 @@ async function handleTerminal(deps: RealtimeRecordingRouterDeps, req: Request, r
  */
 async function loadAuthorizedSession(deps: RealtimeRecordingRouterDeps, sessionID: string, caller: RealtimeRecordingCaller): Promise<MJAIAgentSessionEntity> {
     const session = await deps.LoadOwnedSession(sessionID, caller.ContextUser, caller.Provider);
-    const conversation = await deps.LoadConversationScope(session, caller.ContextUser, caller.Provider);
-    const decision = AuthorizeSessionAccess(
-        { SessionUserID: session.UserID, ConversationExternalID: conversation.ExternalID, ConversationReadable: conversation.Readable },
-        caller.ContextUser,
-    );
+    const decision = await deps.AuthorizeSession(session, caller.ContextUser, caller.Provider);
     if (decision.Allowed === false) {
         LogError(`RealtimeRecordingHandler: refused user ${caller.ContextUser.ID} on session ${sessionID}: ${decision.Reason}`);
         throw new RecordingRequestError(403, 'Not authorized for this realtime session');

package/src/rest/ViewOperationsHandler.ts

@@ -2,6 +2,7 @@ import {
     BaseEntity, EntityInfo, LogError, Metadata, RunView, RunViewParams, 
     RunViewResult, UserInfo, type IRunViewProvider 
 } from '@memberjunction/core';
+import { EscapeSQLString } from '@memberjunction/global';
 import { ClientClauseScreen } from '@memberjunction/generic-database-provider';
 import { ProjectRowsForCaller } from '../generic/fieldSecurityTransport.js';
 
@@ -163,7 +164,7 @@ export class ViewOperationsHandler {
             // Run a view to get the available views
             const params: RunViewParams = {
                 EntityName: 'MJ: User Views',
-                ExtraFilter: `Entity = '${entityName}'`
+                ExtraFilter: `Entity = '${EscapeSQLString(entity.Name)}'`
             };
             
             const runView = new RunView();

package/src/rest/setupRESTEndpoints.ts

@@ -53,10 +53,12 @@ export interface RESTApiOptions {
 }
 
 /**
- * Default REST API configuration
+ * Default REST API configuration. Disabled by default (matching the documented default and
+ * MJServer's own config default): mounting a full-entity REST API must be an explicit decision,
+ * never a side effect of calling SetupRESTEndpoints with no options.
  */
 export const DEFAULT_REST_API_OPTIONS: RESTApiOptions = {
-    enabled: true,
+    enabled: false,
 };
 
 /**
@@ -95,6 +97,13 @@ export function SetupRESTEndpoints(
     if (authMiddleware) {
         app.use(basePath, BodyParser.json({ limit: '50mb' }), authMiddleware, restHandler.getRouter());
     } else {
+        // MJServer itself is safe here (its unified auth middleware runs globally before this
+        // mount), but a third-party caller passing no authMiddleware may be mounting a fully
+        // UNauthenticated entity CRUD API — say so loudly.
+        LogStatusEx({
+            message: `REST API mounted at ${basePath} WITHOUT a route-level auth middleware. ` +
+                `Ensure an authentication middleware runs globally before this mount, or pass one to SetupRESTEndpoints.`,
+        });
         app.use(basePath, BodyParser.json({ limit: '50mb' }), restHandler.getRouter());
     }
 

package/src/services/DurableEntityActionTaskSubmitter.ts

@@ -15,7 +15,7 @@ import type {
     DurableEntityActionSubmission,
     DurableEntityActionSubmitter,
 } from '@memberjunction/actions-base';
-import { LogError } from '@memberjunction/core';
+import { type IEntityDataProvider, type IMetadataProvider, LogError } from '@memberjunction/core';
 import { TaskNode, type TaskGraphSpec } from '@memberjunction/ai-core-plus';
 import { MJEnvironmentEntityExtended } from '@memberjunction/core-entities';
 import { TaskGraphService, type ProviderFactory } from '@memberjunction/task-graph';
@@ -59,7 +59,9 @@ export class DurableEntityActionTaskSubmitter implements DurableEntityActionSubm
                 durable: true,
             };
 
-            const provider = await this.providerFactory.CreateProvider();
+            const provider: IMetadataProvider = isMetadataProvider(request.Provider)
+                ? request.Provider
+                : await this.providerFactory.CreateProvider();
             const result = await new TaskGraphService().Submit(spec, {
                 EnvironmentID: this.environmentID,
                 ContextUser: request.ContextUser,
@@ -76,3 +78,9 @@ export class DurableEntityActionTaskSubmitter implements DurableEntityActionSubm
         }
     }
 }
+
+function isMetadataProvider(
+    provider: IMetadataProvider | IEntityDataProvider | undefined,
+): provider is IMetadataProvider {
+    return !!provider && 'GetEntityObject' in provider && typeof provider.GetEntityObject === 'function';
+}

package/src/services/TaskGraphActionRunner.ts

@@ -11,6 +11,7 @@
  */
 import { ActionEngineServer } from '@memberjunction/actions';
 import { ActionParam } from '@memberjunction/actions-base';
+import { BuildActionOutputObject } from '@memberjunction/ai-core-plus';
 import { LogError } from '@memberjunction/core';
 import { UUIDsEqual } from '@memberjunction/global';
 import type { TaskActionRunner, TaskActionRunParams, TaskActionRunResult } from '@memberjunction/task-graph';
@@ -97,29 +98,7 @@ export class TaskGraphActionRunner implements TaskActionRunner {
      * produced.
      */
     private buildOutput(actionParams: ActionParam[], resultMessage?: string | null): Record<string, unknown> {
-        const output: Record<string, unknown> = {};
-        if (typeof resultMessage === 'string') {
-            const trimmed = resultMessage.trim();
-            if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
-                try {
-                    const parsed: unknown = JSON.parse(trimmed);
-                    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-                        Object.assign(output, parsed as Record<string, unknown>);
-                    }
-                } catch {
-                    // Non-JSON prose message; ignore.
-                }
-            }
-        }
-        for (const p of actionParams ?? []) {
-            if (p.Type === 'Output' || p.Type === 'Both') output[p.Name] = p.Value;
-        }
-        if (typeof output.handle === 'string' && output.Handle === undefined) {
-            output.Handle = output.handle;
-        } else if (typeof output.Handle === 'string' && output.handle === undefined) {
-            output.handle = output.Handle;
-        }
-        return output;
+        return BuildActionOutputObject(actionParams, resultMessage);
     }
 
     /**