@memberjunction/server 5.38.0 → 5.40.0

package/src/resolvers/RunTestResolver.ts

@@ -16,6 +16,7 @@ import { LogError, LogStatus, UserInfo } from '@memberjunction/core';
 import { TestEngine } from '@memberjunction/testing-engine';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { PUSH_STATUS_UPDATES_TOPIC } from '../generic/PushStatusResolver.js';
+import { startLivenessPulse } from '../generic/FireAndForgetHeartbeat.js';
 import { TestRunVariables, TestLogMessage, TestRunResult as EngineTestRunResult } from '@memberjunction/testing-engine-base';
 
 // ===== GraphQL Types =====
@@ -254,12 +255,17 @@ export class RunTestResolver extends ResolverBase {
         userPayload: UserPayload,
         user: UserInfo
     ): void {
+        // Keep-alive pulse so a long-running test never trips the client idle timeout.
+        // The client captures the testRunId from progress events for reconciliation.
+        const pulse = startLivenessPulse({ pubSub, sessionId: userPayload.sessionId, resolver: 'RunTestResolver' });
+
         this.executeTest(testId, verbose, environment, tags, variables, pubSub, userPayload, user)
             .catch((error: unknown) => {
                 const errorMessage = (error instanceof Error) ? error.message : 'Unknown background test execution error';
                 LogError(`🔥 Fire-and-forget test execution failed: ${errorMessage}`, undefined, error);
                 this.publishFireAndForgetError(pubSub, userPayload, testId, errorMessage);
-            });
+            })
+            .finally(() => pulse.stop());
     }
 
     /**
@@ -343,6 +349,12 @@ export class RunTestResolver extends ResolverBase {
         userPayload: UserPayload,
         user: UserInfo
     ): void {
+        // Keep-alive pulse so a long-running suite never trips the client idle timeout.
+        // (Suite reconciliation isn't wired: suite progress carries the per-test run id, not the
+        // Test Suite Run id, so the client has no handle to reconcile against — the pulse is the
+        // protection here.)
+        const pulse = startLivenessPulse({ pubSub, sessionId: userPayload.sessionId, resolver: 'RunTestResolver' });
+
         this.executeSuite(
             suiteId, verbose, environment, parallel, tags, variables,
             selectedTestIds, sequenceStart, sequenceEnd, pubSub, userPayload, user
@@ -350,7 +362,7 @@ export class RunTestResolver extends ResolverBase {
             const errorMessage = (error instanceof Error) ? error.message : 'Unknown background suite execution error';
             LogError(`🔥 Fire-and-forget suite execution failed: ${errorMessage}`, undefined, error);
             this.publishFireAndForgetSuiteError(pubSub, userPayload, suiteId, errorMessage);
-        });
+        }).finally(() => pulse.stop());
     }
 
     // ===== Result Building =====

package/src/resolvers/SearchEntitiesResolver.ts

@@ -0,0 +1,173 @@
+import { Arg, Ctx, Field, Float, InputType, Int, ObjectType, Query, Resolver } from 'type-graphql';
+import { EntitySearchResult, SearchEntityParams } from '@memberjunction/core';
+import { AppContext } from '../types.js';
+import { UserCache } from '@memberjunction/sqlserver-dataprovider';
+import { GetReadOnlyProvider } from '../util.js';
+
+/**
+ * GraphQL surface for {@link Metadata.Provider.SearchEntity} / `SearchEntities`.
+ *
+ * Both client forms ({@link GraphQLDataProvider.SearchEntity} and `SearchEntities`)
+ * proxy through this single batched resolver — one HTTP round-trip carries N
+ * per-entity searches in both directions. The actual ranking (lexical +
+ * semantic + RRF blend + permission filter) runs server-side via
+ * `GenericDatabaseProvider.SearchEntity`, fanned out concurrently across
+ * the input list.
+ *
+ * Result groups are aligned by input order so the client can map them back
+ * to the original `params[i]` slot without needing the entity name.
+ */
+
+@InputType()
+export class SearchEntityInput {
+    @Field(() => String)
+    declare EntityName: string;
+
+    @Field(() => String)
+    declare SearchText: string;
+
+    @Field(() => String, { nullable: true })
+    Mode?: 'lexical' | 'semantic' | 'hybrid';
+
+    @Field(() => Int, { nullable: true })
+    RrfK?: number;
+
+    @Field(() => Float, { nullable: true })
+    LexicalWeight?: number;
+
+    @Field(() => Float, { nullable: true })
+    SemanticWeight?: number;
+
+    @Field(() => Int, { nullable: true })
+    TopK?: number;
+
+    @Field(() => Float, { nullable: true })
+    MinScore?: number;
+
+    @Field(() => String, { nullable: true })
+    EntityDocumentID?: string;
+}
+
+@ObjectType()
+export class EntitySearchResultType {
+    @Field(() => String, { nullable: true })
+    declare EntityRecordDocumentID: string | null;
+
+    @Field(() => String)
+    declare RecordID: string;
+
+    @Field(() => Float)
+    declare Score: number;
+
+    @Field(() => String)
+    declare MatchType: 'lexical' | 'semantic' | 'hybrid';
+
+    @Field(() => Float, { nullable: true })
+    LexicalScore?: number | null;
+
+    @Field(() => Float, { nullable: true })
+    SemanticScore?: number | null;
+}
+
+@ObjectType()
+export class EntitySearchResultGroupType {
+    @Field(() => String)
+    declare EntityName: string;
+
+    @Field(() => [EntitySearchResultType])
+    declare Results: EntitySearchResultType[];
+}
+
+@ObjectType()
+export class SearchEntitiesResponseType {
+    @Field(() => Boolean)
+    declare Success: boolean;
+
+    @Field(() => String, { nullable: true })
+    ErrorMessage?: string;
+
+    @Field(() => [EntitySearchResultGroupType])
+    declare Groups: EntitySearchResultGroupType[];
+}
+
+/**
+ * Per-request cap on how many entities a single `SearchEntities` call may
+ * search. Each entity in the batch triggers 2–4 RunViews server-side; an
+ * uncapped batch from a malicious or buggy client could fan out into
+ * thousands of concurrent DB queries. 20 covers every realistic use case
+ * (agent prompt seeding, multi-entity navbar search) with margin to spare.
+ */
+const MAX_SEARCH_ENTITIES_BATCH_SIZE = 20;
+
+@Resolver(SearchEntitiesResponseType)
+export class SearchEntitiesResolver {
+    @Query(() => SearchEntitiesResponseType)
+    async SearchEntities(
+        @Ctx() { providers, userPayload }: AppContext,
+        @Arg('params', () => [SearchEntityInput]) params: SearchEntityInput[]
+    ): Promise<SearchEntitiesResponseType> {
+        try {
+            if (params.length > MAX_SEARCH_ENTITIES_BATCH_SIZE) {
+                return {
+                    Success: false,
+                    ErrorMessage: `Batch size ${params.length} exceeds the per-request cap of ${MAX_SEARCH_ENTITIES_BATCH_SIZE}. Split the request.`,
+                    Groups: params.map(p => ({ EntityName: p.EntityName, Results: [] })),
+                };
+            }
+            const md = GetReadOnlyProvider(providers);
+            const user = UserCache.Instance.Users.find(
+                (u) => u.Email.trim().toLowerCase() === userPayload.email.trim().toLowerCase()
+            );
+            if (!user) {
+                return {
+                    Success: false,
+                    ErrorMessage: `User ${userPayload.email} not found`,
+                    Groups: params.map(p => ({ EntityName: p.EntityName, Results: [] })),
+                };
+            }
+
+            const callParams: SearchEntityParams[] = params.map(p => ({
+                entityName: p.EntityName,
+                searchText: p.SearchText,
+                options: {
+                    mode: p.Mode ?? 'hybrid',
+                    rrfK: p.RrfK ?? undefined,
+                    weights: {
+                        lexical: p.LexicalWeight ?? undefined,
+                        semantic: p.SemanticWeight ?? undefined,
+                    },
+                    topK: p.TopK ?? undefined,
+                    minScore: p.MinScore ?? undefined,
+                    entityDocumentId: p.EntityDocumentID ?? undefined,
+                    contextUser: user,
+                },
+            }));
+
+            // Server-side provider fans the batch out via Promise.all under the
+            // hood — see ProviderBase.SearchEntities. Results arrive aligned by
+            // input order; we just map each group's records to the GraphQL shape.
+            const groupedResults: EntitySearchResult[][] = await md.SearchEntities(callParams);
+
+            return {
+                Success: true,
+                Groups: groupedResults.map((results, i) => ({
+                    EntityName: params[i].EntityName,
+                    Results: results.map(r => ({
+                        EntityRecordDocumentID: r.entityRecordDocumentId,
+                        RecordID: r.recordId,
+                        Score: r.score,
+                        MatchType: r.matchType,
+                        LexicalScore: r.components.lexical ?? null,
+                        SemanticScore: r.components.semantic ?? null,
+                    })),
+                })),
+            };
+        } catch (e) {
+            return {
+                Success: false,
+                ErrorMessage: e instanceof Error ? e.message : String(e),
+                Groups: params.map(p => ({ EntityName: p.EntityName, Results: [] })),
+            };
+        }
+    }
+}

package/src/resolvers/UserResolver.ts

@@ -1,9 +1,45 @@
-import { AppContext, Arg, Ctx, Int, Query, Resolver } from '@memberjunction/server';
-import { MJUser_, MJUserResolverBase } from '../generated/generated.js';
+import { AppContext, Arg, Ctx, FieldResolver, Int, PubSub, PubSubEngine, Query, Resolver, Root } from '@memberjunction/server';
+import { UUIDsEqual } from '@memberjunction/global';
+import { MJUser_, MJUserRole_, MJUserResolverBase } from '../generated/generated.js';
 import { GetReadOnlyProvider } from '../util.js';
 
 @Resolver(MJUser_)
 export class UserResolver extends MJUserResolverBase {
+
+  /**
+   * Roles for the current user row.
+   *
+   * Overrides the generated field resolver to support ANONYMOUS magic-link sessions: those
+   * resolve to a shared Anonymous principal that holds NO roles in the database (by design —
+   * persisting them would let anonymous sessions accrete privileges across links). The roles
+   * are synthesized per-request in {@link buildMagicLinkSessionUser} and live only on the
+   * request's `UserInfo`. For the session's OWN user row we serve those synthesized roles
+   * directly, skipping the generated DB query (which returns empty) and its `MJ: User Roles`
+   * read-permission check (which the restricted anon role wouldn't pass). Every other case —
+   * named users, named magic-link users, listing other users' roles — falls through to the
+   * generated resolver unchanged, so there is no behavioral or security change off this path.
+   */
+  @FieldResolver(() => [MJUserRole_])
+  async MJUserRoles_UserIDArray(@Root() mjuser_: MJUser_, @Ctx() context: AppContext, @PubSub() pubSub: PubSubEngine) {
+    const sessionUser = context.userPayload?.userRecord;
+    if (sessionUser?.IsMagicLinkAnonymous && UUIDsEqual(mjuser_.ID, sessionUser.ID)) {
+      const now = new Date();
+      // Build rows with the entity's RAW field names, then run them through the same
+      // name→code-name mapping the generated resolver uses (e.g. __mj_CreatedAt →
+      // _mj__CreatedAt). Returning raw names directly trips GraphQL's non-nullable check.
+      const rows = (sessionUser.UserRoles ?? []).map((r: { UserID: string; RoleID: string; RoleName?: string; Role?: string }) => ({
+        ID: sessionUser.ID,
+        UserID: r.UserID,
+        RoleID: r.RoleID,
+        User: sessionUser.Name,
+        Role: r.RoleName ?? r.Role,
+        __mj_CreatedAt: now,
+        __mj_UpdatedAt: now,
+      }));
+      return this.ArrayMapFieldNamesToCodeNames('MJ: User Roles', rows, sessionUser);
+    }
+    return super.MJUserRoles_UserIDArray(mjuser_, context, pubSub);
+  }
   @Query(() => MJUser_)
   async CurrentUser(@Ctx() context: AppContext) {
     // Check API key scope authorization for user read (self)

package/src/resolvers/VectorizeEntityResolver.ts

@@ -90,7 +90,13 @@ export class VectorizeEntityResolver extends ResolverBase {
             };
 
             const result = await syncer.VectorizeEntity(params, currentUser);
-            LogStatus(`VectorizeEntity pipeline ${pipelineRunID} complete: success=${result.success}`);
+            if (result.success) {
+                LogStatus(`VectorizeEntity pipeline ${pipelineRunID} complete: success=true`);
+            } else {
+                // The run finished but some/all records failed to render or upsert. Surface it
+                // loudly instead of logging a bare "success=false" that reads like a clean finish.
+                LogError(`VectorizeEntity pipeline ${pipelineRunID} completed with errors (status=${result.status}): ${result.errorMessage}`);
+            }
         } catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
             LogError(`VectorizeEntity pipeline ${pipelineRunID} failed: ${msg}`);
@@ -110,11 +116,18 @@ export class VectorizeEntityResolver extends ResolverBase {
      * Publish a progress update to the PipelineProgress subscription topic.
      */
     private publishProgress(pipelineRunID: string, update: VectorizeProgressUpdate): void {
+        // Carry a short error summary to the client via CurrentItem when the update reports failures,
+        // so the subscription reflects that the run didn't cleanly succeed.
+        const errorSummary = update.Errors && update.Errors.length > 0
+            ? `${update.Errors.length} record(s) failed — e.g. ${update.Errors[0].Message}`
+            : undefined;
+
         const notification: PipelineProgressNotification = {
             PipelineRunID: pipelineRunID,
             Stage: update.Stage,
             TotalItems: update.TotalRecords,
             ProcessedItems: update.ProcessedRecords,
+            CurrentItem: errorSummary,
             ElapsedMs: update.ElapsedMs,
             PercentComplete: update.PercentComplete,
         };

package/src/resolvers/__tests__/IntegrationProgressResolver.test.ts

@@ -0,0 +1,170 @@
+// type-graphql decorators (`@Field`, `@ObjectType`) call `Reflect.getMetadata`,
+// which only exists once this polyfill is loaded. Vitest doesn't bring it in
+// automatically — it MUST come before any import that pulls in the resolver file.
+import 'reflect-metadata';
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock the PubSubManager singleton so PublishIntegrationProgress never touches a
+// real PubSubEngine (no network, no resolver-build dependency).
+const publishSpy = vi.fn();
+vi.mock('../../generic/PubSubManager.js', () => ({
+    PubSubManager: {
+        Instance: {
+            Publish: (...args: unknown[]) => publishSpy(...args),
+        },
+    },
+}));
+
+// Silence LogError so a deliberately-failing serialization test doesn't spam output.
+vi.mock('@memberjunction/core', () => ({
+    LogError: vi.fn(),
+}));
+
+import {
+    INTEGRATION_PROGRESS_TOPIC,
+    IntegrationProgressTopicForKind,
+    BuildIntegrationProgressNotification,
+    MatchesIntegrationSubscription,
+    PublishIntegrationProgress,
+    type IntegrationProgressNotification,
+    type PublishIntegrationProgressArgs,
+} from '../IntegrationProgressResolver';
+
+const baseArgs = (overrides: Partial<PublishIntegrationProgressArgs> = {}): PublishIntegrationProgressArgs => ({
+    RunID: 'run-1',
+    Kind: 'SyncRun',
+    EventType: 'stage.start',
+    Seq: 1,
+    CompanyIntegrationID: 'ci-1',
+    Message: 'starting',
+    Stage: 'extract',
+    Level: 'info',
+    Data: { foo: 'bar' },
+    ...overrides,
+});
+
+const baseNotification = (overrides: Partial<IntegrationProgressNotification> = {}): IntegrationProgressNotification => ({
+    RunID: 'run-1',
+    CompanyIntegrationID: 'ci-1',
+    Kind: 'SyncRun',
+    Topic: 'Sync',
+    EventType: 'stage.start',
+    Seq: 1,
+    Message: 'starting',
+    Stage: 'extract',
+    Level: 'info',
+    DataJSON: '{"foo":"bar"}',
+    ...overrides,
+});
+
+describe('IntegrationProgressTopicForKind', () => {
+    it('maps each run kind to its logical channel', () => {
+        expect(IntegrationProgressTopicForKind('Discovery')).toBe('MetadataRefresh');
+        expect(IntegrationProgressTopicForKind('Enrichment')).toBe('MetadataRefresh');
+        expect(IntegrationProgressTopicForKind('ConnectorCreation')).toBe('ConnectorCreation');
+        expect(IntegrationProgressTopicForKind('SyncRun')).toBe('Sync');
+        expect(IntegrationProgressTopicForKind('RSU')).toBe('RSU');
+        expect(IntegrationProgressTopicForKind('TableCreation')).toBe('RSU');
+    });
+
+    it('returns undefined for kinds without a dedicated channel', () => {
+        expect(IntegrationProgressTopicForKind('Other')).toBeUndefined();
+    });
+});
+
+describe('BuildIntegrationProgressNotification', () => {
+    it('builds the full notification shape with derived topic and serialized data', () => {
+        const n = BuildIntegrationProgressNotification(baseArgs());
+        expect(n).toEqual(baseNotification());
+    });
+
+    it('derives ConnectorCreation topic from ConnectorCreation kind', () => {
+        const n = BuildIntegrationProgressNotification(baseArgs({ Kind: 'ConnectorCreation' }));
+        expect(n.Kind).toBe('ConnectorCreation');
+        expect(n.Topic).toBe('ConnectorCreation');
+    });
+
+    it('leaves DataJSON undefined when no data is supplied', () => {
+        const n = BuildIntegrationProgressNotification(baseArgs({ Data: undefined }));
+        expect(n.DataJSON).toBeUndefined();
+    });
+
+    it('swallows un-serializable data and leaves DataJSON undefined', () => {
+        const cyclic: Record<string, unknown> = {};
+        cyclic.self = cyclic;
+        const n = BuildIntegrationProgressNotification(baseArgs({ Data: cyclic }));
+        expect(n.DataJSON).toBeUndefined();
+        // The rest of the payload is unaffected.
+        expect(n.RunID).toBe('run-1');
+        expect(n.Topic).toBe('Sync');
+    });
+
+    it('omits Topic for an Other-kind run', () => {
+        const n = BuildIntegrationProgressNotification(baseArgs({ Kind: 'Other' }));
+        expect(n.Topic).toBeUndefined();
+    });
+});
+
+describe('MatchesIntegrationSubscription', () => {
+    it('matches everything when no args are supplied', () => {
+        expect(MatchesIntegrationSubscription(baseNotification(), {})).toBe(true);
+    });
+
+    it('filters by runID', () => {
+        const n = baseNotification();
+        expect(MatchesIntegrationSubscription(n, { runID: 'run-1' })).toBe(true);
+        expect(MatchesIntegrationSubscription(n, { runID: 'run-2' })).toBe(false);
+    });
+
+    it('filters by companyIntegrationID', () => {
+        const n = baseNotification();
+        expect(MatchesIntegrationSubscription(n, { companyIntegrationID: 'ci-1' })).toBe(true);
+        expect(MatchesIntegrationSubscription(n, { companyIntegrationID: 'ci-2' })).toBe(false);
+    });
+
+    it('filters by topic', () => {
+        const n = baseNotification({ Topic: 'Sync' });
+        expect(MatchesIntegrationSubscription(n, { topic: 'Sync' })).toBe(true);
+        expect(MatchesIntegrationSubscription(n, { topic: 'RSU' })).toBe(false);
+    });
+
+    it('requires all supplied filters to match', () => {
+        const n = baseNotification();
+        expect(MatchesIntegrationSubscription(n, { runID: 'run-1', topic: 'Sync', companyIntegrationID: 'ci-1' })).toBe(true);
+        expect(MatchesIntegrationSubscription(n, { runID: 'run-1', topic: 'RSU' })).toBe(false);
+    });
+});
+
+describe('PublishIntegrationProgress', () => {
+    beforeEach(() => {
+        publishSpy.mockClear();
+    });
+
+    it('publishes the built notification to the integration topic and returns it', () => {
+        const result = PublishIntegrationProgress(baseArgs());
+
+        expect(result).toEqual(baseNotification());
+        expect(publishSpy).toHaveBeenCalledTimes(1);
+
+        const [topic, payload] = publishSpy.mock.calls[0];
+        expect(topic).toBe(INTEGRATION_PROGRESS_TOPIC);
+        expect(payload).toEqual(baseNotification());
+    });
+
+    it('publishes a fresh object copy (not the internal notification reference)', () => {
+        const result = PublishIntegrationProgress(baseArgs());
+        const [, payload] = publishSpy.mock.calls[0];
+        // Spread copy semantics: structurally equal but a distinct instance.
+        expect(payload).not.toBe(result);
+        expect(payload).toEqual(result);
+    });
+
+    it('returns undefined and does not throw when publishing fails', () => {
+        publishSpy.mockImplementationOnce(() => {
+            throw new Error('pubsub down');
+        });
+        const result = PublishIntegrationProgress(baseArgs());
+        expect(result).toBeUndefined();
+    });
+});

package/src/rest/SignatureWebhookHandler.ts

@@ -0,0 +1,103 @@
+/**
+ * @fileoverview Inbound eSignature webhook handler (DocuSign Connect, Adobe events, …).
+ *
+ * Unauthenticated by design — external signature providers call this endpoint without an MJ bearer
+ * token. Payload authenticity is verified by the provider DRIVER's `ParseWebhookEvent` (HMAC /
+ * signature), not by MJ auth. Must be registered BEFORE the unified auth middleware.
+ *
+ * Endpoint:
+ *   - POST /esignature/webhook/:driverKey
+ *
+ * @module @memberjunction/server/rest/SignatureWebhookHandler
+ */
+
+import express from 'express';
+import BodyParser from 'body-parser';
+import { LogError, LogStatus, UserInfo } from '@memberjunction/core';
+import { UserCache } from '@memberjunction/sqlserver-dataprovider';
+import { SignatureEngine } from '@memberjunction/esignature/server';
+
+/**
+ * Build an Express router exposing the eSignature webhook. Mount it unauthenticated:
+ * `app.use('/esignature', createSignatureWebhookHandler())`.
+ */
+export function createSignatureWebhookHandler(): express.Router {
+    const router = express.Router();
+
+    // Capture the raw body so drivers that HMAC-verify over the exact bytes can do so.
+    router.post(
+        '/webhook/:driverKey',
+        BodyParser.json({ limit: '25mb', verify: captureRawBody }),
+        async (req: express.Request, res: express.Response) => {
+            await handleWebhook(req, res);
+        },
+    );
+
+    return router;
+}
+
+/** Stash the raw request bytes on the request for signature verification by the driver. */
+function captureRawBody(req: express.Request, _res: express.Response, buf: Buffer): void {
+    (req as RawBodyRequest).rawBody = buf;
+}
+
+async function handleWebhook(req: express.Request, res: express.Response): Promise<void> {
+    const driverKey = req.params.driverKey;
+    if (!driverKey) {
+        res.status(400).json({ error: 'Missing driver key in path.' });
+        return;
+    }
+
+    const contextUser = getSystemUser();
+    if (!contextUser) {
+        LogError('[eSignature webhook] No system user available; cannot process webhook.');
+        res.status(503).json({ error: 'Server not ready to process webhooks.' });
+        return;
+    }
+
+    try {
+        await SignatureEngine.Instance.Config(false, contextUser);
+        const headers = normalizeHeaders(req.headers);
+        const rawBody = (req as RawBodyRequest).rawBody;
+        const result = await SignatureEngine.Instance.RecordWebhookEvent(driverKey, req.body, headers, contextUser, rawBody);
+
+        if (!result.Success) {
+            // 202: we received it but couldn't act (e.g. unrecognized payload / no matching envelope).
+            // Returning 2xx prevents most providers from aggressively retrying a payload we'll never match.
+            LogStatus(`[eSignature webhook] ${driverKey}: not actioned — ${result.ErrorMessage}`);
+            res.status(202).json({ received: true, actioned: false, message: result.ErrorMessage });
+            return;
+        }
+
+        res.status(200).json({ received: true, actioned: true, status: result.event?.status });
+    } catch (e) {
+        LogError(`[eSignature webhook] ${driverKey}: ${e instanceof Error ? e.message : String(e)}`);
+        res.status(500).json({ error: 'Failed to process webhook.' });
+    }
+}
+
+/** Flatten Express header values to a simple string map for the driver. */
+function normalizeHeaders(headers: express.Request['headers']): Record<string, string> {
+    const out: Record<string, string> = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (typeof value === 'string') {
+            out[key] = value;
+        } else if (Array.isArray(value)) {
+            out[key] = value.join(', ');
+        }
+    }
+    return out;
+}
+
+function getSystemUser(): UserInfo | null {
+    try {
+        return UserCache.Instance.GetSystemUser() ?? null;
+    } catch {
+        return null;
+    }
+}
+
+/** Express request augmented with the captured raw body. */
+interface RawBodyRequest extends express.Request {
+    rawBody?: Buffer;
+}

package/src/services/ScheduledJobsService.ts

@@ -67,7 +67,18 @@ export class ScheduledJobsService {
         }
 
         try {
-            this.engine.StartPolling(this.systemUser);
+            // Wire engine tunables from MJServer's scheduledJobs config block.
+            // Both fields have schema defaults (maxConcurrentJobs=5, defaultLockTimeout=600000ms),
+            // but apply explicitly so the values are visible in startup logs and
+            // a future config change is picked up without an engine code change.
+            if (this.config.maxConcurrentJobs != null) {
+                this.engine.MaxConcurrentJobs = this.config.maxConcurrentJobs;
+            }
+            if (this.config.defaultLockTimeout != null) {
+                this.engine.LeaseTimeoutMs = this.config.defaultLockTimeout;
+            }
+
+            await this.engine.StartPolling(this.systemUser);
             this.isRunning = true;
 
             // Single consolidated console message
@@ -102,7 +113,9 @@ export class ScheduledJobsService {
 
         try {
             LogStatus('[ScheduledJobsService] Stopping scheduled job polling');
-            this.engine.StopPolling();
+            // Graceful shutdown: wait for in-flight dispatched jobs to settle,
+            // bounded by 30s so a zombie can't hang the shutdown indefinitely.
+            await this.engine.StopPolling({ waitForInflight: true, maxWaitMs: 30_000 });
             this.isRunning = false;
             LogStatus('[ScheduledJobsService] Polling stopped successfully');
         } catch (error) {