@memberjunction/server 5.40.2 → 5.42.0

package/src/agentSessions/remoteBrowserGoalRegistry.ts

@@ -0,0 +1,122 @@
+import { BaseSingleton } from '@memberjunction/global';
+
+/**
+ * Terminal/structural outcome of a remote-browser goal run — the fields the client needs to render
+ * the result, decoupled from the GraphQL `RemoteBrowserGoalResultType` (avoids a resolver↔registry
+ * import cycle) and from the engine's `RemoteBrowserGoalResult` (whose `Strategy` is a string union).
+ */
+export interface RemoteBrowserGoalOutcome {
+  Success: boolean;
+  Strategy?: string;
+  CurrentUrl?: string;
+  Status?: string;
+  StepCount?: number;
+  Detail?: string;
+}
+
+type GoalRunStatus = 'Running' | 'Complete';
+
+/** One tracked goal run: its lifecycle status plus the terminal outcome once it finishes. */
+export interface GoalRunRecord {
+  GoalRunID: string;
+  /** Lowercased `AIAgentSession` id the goal runs against (one in-flight goal per session). */
+  AgentSessionID: string;
+  Status: GoalRunStatus;
+  Outcome?: RemoteBrowserGoalOutcome;
+  StartedAt: number;
+  CompletedAt?: number;
+}
+
+/** Default time a COMPLETED record is retained so a slow poller can still read it (then swept). */
+const COMPLETED_TTL_MS = 5 * 60 * 1000;
+/** Safety cap: a record that never completes (e.g. a crashed loop) is swept after this long. */
+const RUNNING_MAX_MS = 30 * 60 * 1000;
+
+/**
+ * Process-local registry of in-flight + recently-completed remote-browser GOAL runs.
+ *
+ * ## Why this exists
+ * A goal-driven browser run (computer-use loop) can take many minutes. Running it inside a single
+ * synchronous GraphQL mutation means the client holds one long-lived HTTP request open for the whole
+ * loop — fragile against browser fetch timeouts, proxy/ngrok idle limits, and session-janitor churn.
+ * Observed symptom: the loop completes successfully server-side but the client's request has already
+ * died, so the agent gets "no response from the server" and never learns the outcome.
+ *
+ * The fix is async: the start mutation kicks the goal off and registers it here (status `Running`),
+ * returning a `GoalRunID` immediately; the client then POLLS a short query that reads this registry
+ * until the run is `Complete`. Every request stays short, so no transport boundary times out.
+ *
+ * Keyed by `AIAgentSession` id (at most one in-flight goal per session, mirroring the engine's
+ * per-session abort registry). Process-local is correct: the browser session — and thus the goal —
+ * is pinned to the MJAPI instance hosting its CDP connection, the same instance the client's
+ * session-scoped mutations already target.
+ */
+export class RemoteBrowserGoalRegistry extends BaseSingleton<RemoteBrowserGoalRegistry> {
+  private runs = new Map<string, GoalRunRecord>();
+
+  protected constructor() {
+    super();
+  }
+
+  public static get Instance(): RemoteBrowserGoalRegistry {
+    return super.getInstance<RemoteBrowserGoalRegistry>();
+  }
+
+  private key(agentSessionID: string): string {
+    return (agentSessionID ?? '').toLowerCase();
+  }
+
+  /** Registers a newly-started goal as `Running`, replacing any prior record for the session. */
+  public Begin(agentSessionID: string, goalRunID: string): void {
+    this.sweep();
+    this.runs.set(this.key(agentSessionID), {
+      GoalRunID: goalRunID,
+      AgentSessionID: this.key(agentSessionID),
+      Status: 'Running',
+      StartedAt: Date.now(),
+    });
+  }
+
+  /**
+   * Marks a goal run `Complete` with its terminal outcome. No-op when the session's current record is
+   * for a DIFFERENT `goalRunID` (a newer goal superseded it) — the stale completion is dropped.
+   */
+  public Complete(agentSessionID: string, goalRunID: string, outcome: RemoteBrowserGoalOutcome): void {
+    const rec = this.runs.get(this.key(agentSessionID));
+    if (!rec || rec.GoalRunID !== goalRunID) {
+      return;
+    }
+    rec.Status = 'Complete';
+    rec.Outcome = outcome;
+    rec.CompletedAt = Date.now();
+  }
+
+  /**
+   * Returns the tracked record for a session, or `undefined` when none exists or `goalRunID` is
+   * supplied and doesn't match the current run (so a poll for an expired/superseded id reads nothing).
+   */
+  public Get(agentSessionID: string, goalRunID?: string): GoalRunRecord | undefined {
+    this.sweep();
+    const rec = this.runs.get(this.key(agentSessionID));
+    if (!rec) {
+      return undefined;
+    }
+    if (goalRunID && rec.GoalRunID !== goalRunID) {
+      return undefined;
+    }
+    return rec;
+  }
+
+  /** Drops completed records past their TTL and never-completing records past the safety cap. */
+  private sweep(): void {
+    const now = Date.now();
+    for (const [k, rec] of this.runs) {
+      const expired =
+        (rec.Status === 'Complete' && rec.CompletedAt != null && now - rec.CompletedAt > COMPLETED_TTL_MS) ||
+        now - rec.StartedAt > RUNNING_MAX_MS;
+      if (expired) {
+        this.runs.delete(k);
+      }
+    }
+  }
+}

package/src/auth/initializeProviders.ts

@@ -1,5 +1,5 @@
 import { configInfo } from '../config.js';
-import { AuthProviderConfig, LogError, LogStatus } from '@memberjunction/core';
+import { AuthProviderConfig, LogError } from '@memberjunction/core';
 import { AuthProviderFactory } from '@memberjunction/auth-providers';
 
 /**
@@ -16,8 +16,10 @@ export function initializeAuthProviders(): void {
     for (const providerConfig of configInfo.authProviders) {
       try {
         const provider = AuthProviderFactory.createProvider(providerConfig as AuthProviderConfig);
+        // register() emits the verbose-only "Registered auth provider: … with issuer: …" line
+        // (gated by the global verbose flag). Provider NAMES are surfaced compactly in the
+        // startup summary `Auth` line at `standard`.
         factory.register(provider);
-        LogStatus(`Registered auth provider: ${provider.name} (type: ${providerConfig.type})`);
       } catch (error) {
         LogError(`Failed to initialize auth provider ${providerConfig.name}: ${error}`);
       }

package/src/config.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { cosmiconfigSync } from 'cosmiconfig';
-import { LogError, LogStatus } from '@memberjunction/core';
+import { LogError, LogStatus, LogStatusEx } from '@memberjunction/core';
 import { mergeConfigs, parseBooleanEnv } from '@memberjunction/config';
 
 const explorer = cosmiconfigSync('mj', { searchStrategy: 'global' });
@@ -586,6 +586,14 @@ export const DEFAULT_SERVER_CONFIG: Partial<ConfigInfo> = {
   ].filter(Boolean),
 };
 
+/**
+ * Absolute path to the resolved config file, captured during {@link loadConfig}.
+ * `undefined` when no config file was found (defaults in use). Rendered in the
+ * startup summary `Config` line. Declared before `configInfo` so the assignment
+ * inside `loadConfig()` (invoked below) is not in its temporal dead zone.
+ */
+export let configFilePath: string | undefined;
+
 export const configInfo: ConfigInfo = loadConfig();
 
 export const {
@@ -621,7 +629,10 @@ export function loadConfig() {
 
   // If user config exists, merge it with defaults
   if (configSearchResult && !configSearchResult.isEmpty) {
-    LogStatus(`Config file found at ${configSearchResult.filepath}`);
+    // Resolved config-file path. Surfaced in the startup summary `Config` line at standard
+    // level (see StartupLogger). Demoted to verbose-only here to avoid a duplicate inline line.
+    configFilePath = configSearchResult.filepath;
+    LogStatusEx({ message: `Config file found at ${configSearchResult.filepath}`, verboseOnly: true });
 
     // Merge user config with defaults (user config takes precedence)
     mergedConfig = mergeConfigs(DEFAULT_SERVER_CONFIG, configSearchResult.config);

package/src/context.ts

@@ -1,5 +1,4 @@
 import { IncomingMessage } from 'http';
-import * as url from 'url';
 import { default as jwt } from 'jsonwebtoken';
 import 'reflect-metadata';
 import { Subject, firstValueFrom } from 'rxjs';
@@ -10,6 +9,7 @@ import { TokenExpiredError, AuthProviderFactory } from '@memberjunction/auth-pro
 import { authCache } from './cache.js';
 import { userEmailMap, apiKey, mj_core_schema } from './config.js';
 import { buildBoundaryLogPayload } from './logging/boundaryLogPayload.js';
+import { StartupLogger } from './logging/StartupLogger.js';
 import { DataSourceInfo, UserPayload } from './types.js';
 import { GetReadOnlyDataSource, GetReadWriteDataSource } from './util.js';
 import { v4 as uuidv4 } from 'uuid';
@@ -30,6 +30,20 @@ import { GetAPIKeyEngine } from '@memberjunction/api-keys';
 // long-lived sessions every hour.) Reviewers asked to audit all user access with
 // timestamp/IP/browser — that payload lives in the Details JSON; the table has no
 // dedicated columns. Best-effort throughout: an audit failure NEVER blocks auth.
+/**
+ * Memoized "is the server log level `debug`?" check for the per-request log
+ * gates below. Resolved once from `telemetry.level` (the single log-level knob)
+ * — config is immutable after boot, so caching is safe and keeps the hot request
+ * path free of repeated config reads.
+ */
+let isDebugLevelCache: boolean | undefined;
+function isDebugLogLevel(): boolean {
+  if (isDebugLevelCache === undefined) {
+    isDebugLevelCache = StartupLogger.resolveLevelFromConfig() === 'debug';
+  }
+  return isDebugLevelCache;
+}
+
 const SESSION_AUDIT_TYPE = 'Session Established';
 const LOGIN_FAILED_AUDIT_TYPE = 'Login Failed';
 const SESSION_AUDIT_CACHE_MAX = 50_000;
@@ -269,9 +283,12 @@ const verifyAsync = async (issuer: string, token: string): Promise<jwt.JwtPayloa
       if (jwt && typeof jwt !== 'string' && !err) {
         const payload = jwt.payload ?? jwt;
 
-        // Use provider to extract user info for logging
-        const userInfo = extractUserInfoFromPayload(payload);
-        console.log(`Valid token: ${userInfo.fullName || 'Unknown'} (${userInfo.email || userInfo.preferredUsername || 'Unknown'})`);
+        // Per-request token confirmation — debug-only (one of the worst
+        // "constantly on" offenders on an authenticated server).
+        if (isDebugLogLevel()) {
+          const userInfo = extractUserInfoFromPayload(payload);
+          console.log(`Valid token: ${userInfo.fullName || 'Unknown'} (${userInfo.email || userInfo.preferredUsername || 'Unknown'})`);
+        }
         resolve(payload);
       } else {
         console.warn('Invalid token');
@@ -462,6 +479,22 @@ export const getUserPayload = async (
  * Extracts auth headers and builds a RequestContext from an Express request.
  * Shared by both the unified auth middleware and the WebSocket context.
  */
+/**
+ * Extracts the hostname from a request `Origin` header using the WHATWG `URL` API (replacing the
+ * deprecated, security-flagged `url.parse()` — Node DEP0169). Returns `undefined` for a missing,
+ * empty, or unparseable origin, matching the prior `url.parse().hostname ?? undefined` semantics.
+ */
+function parseRequestHostname(origin: string | undefined): string | undefined {
+  if (!origin) {
+    return undefined;
+  }
+  try {
+    return new URL(origin).hostname || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 function extractAuthInputs(req: IncomingMessage): {
   bearerToken: string;
   sessionId: string;
@@ -471,7 +504,7 @@ function extractAuthInputs(req: IncomingMessage): {
   requestContext: RequestContext;
 } {
   const sessionIdRaw = req.headers['x-session-id'];
-  const requestDomain = url.parse(req.headers.origin || '');
+  const requestDomain = parseRequestHostname(req.headers.origin);
   const sessionId = sessionIdRaw ? sessionIdRaw.toString() : '';
   const bearerToken = req.headers.authorization ?? '';
   const systemApiKey = String(req.headers['x-mj-api-key']);
@@ -489,7 +522,7 @@ function extractAuthInputs(req: IncomingMessage): {
   return {
     bearerToken,
     sessionId,
-    requestDomain: requestDomain?.hostname ?? undefined,
+    requestDomain,
     systemApiKey,
     userApiKey,
     requestContext,
@@ -573,7 +606,9 @@ export const contextFunction =
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const reqAny = req as any;
     const operationName: string | undefined = reqAny.body?.operationName;
-    if (operationName !== 'IntrospectionQuery') {
+    // Per-request GraphQL boundary line — debug-only. Kept (not deleted) so the
+    // data is available when an operator opts into debug, but off by default.
+    if (operationName !== 'IntrospectionQuery' && isDebugLogLevel()) {
       console.dir(buildBoundaryLogPayload(operationName), { depth: null, breakLength: 200 });
     }