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

package/dist/agentSessions/SessionJanitor.d.ts

@@ -1,61 +1,117 @@
 import { BaseSingleton, IShutdownable } from '@memberjunction/global';
 import { IMetadataProvider, UserInfo } from '@memberjunction/core';
+import { HostInstanceIdentity } from './HostInstance.js';
 /** Tuning knobs for the janitor. All durations in their named units. */
 export interface SessionJanitorConfig {
     /** A non-`Closed` session whose `LastActiveAt` is older than this is force-closed by the global sweep. */
     closeThresholdMinutes: number;
-    /** How often the periodic staleness sweep runs once {@link SessionJanitor.Start} is called. */
+    /** How often the periodic tick (close sweeps, then recording recovery) runs once {@link SessionJanitor.Start} is called. */
     sweepIntervalMs: number;
+    /**
+     * How long after `ClosedAt` a recording-less session waits before recording recovery rebuilds it.
+     * Sessions are closed BEFORE the browser uploads the recording (#5195), so a fresh close without a
+     * recording is normal; recovery must not race the upload that is about to arrive.
+     */
+    recordingRecoveryGraceMinutes: number;
+    /** Sessions closed longer ago than this are no longer considered by recording recovery. */
+    recordingRecoveryLookbackHours: number;
+    /**
+     * How long one session's recovery may run before the sweep abandons it and moves on. Storage clients
+     * can wait forever on a connection that stops answering (the S3 driver sets no request timeout), and
+     * one such call must not hold the single recovery pass for the life of the process.
+     */
+    recordingRecoveryAttemptTimeoutMinutes: number;
 }
 /**
  * `BaseSingleton` background reconciler that keeps the durable `AIAgentSession` state from drifting
  * away from volatile process reality. A crash/redeploy vaporizes a host's in-memory sockets but
  * leaves its session rows reading `Active`/`Idle` forever; the janitor force-closes those orphans.
  *
- * Two sweeps, both writing through {@link SessionManager.CloseSession} so Record Changes captures
+ * Three close sweeps, all writing through {@link SessionManager.CloseSession} so Record Changes captures
  * each transition and channel rows are disconnected consistently:
  *
- * 1. **Own-host recovery ({@link RunStartupRecovery})** — run once at boot. Closes any `Active`/`Idle`
- *    session whose `HostInstanceID` belongs to a *previous* boot of *this* host (same hostname prefix,
- *    different `bootId`). Primary defense against the "Active forever" leak after a restart.
- * 2. **Global staleness sweep ({@link RunStalenessSweep})** — run periodically on every instance.
- *    Closes any `Active`/`Idle` session whose `LastActiveAt` is older than `closeThresholdMinutes`,
- *    regardless of host. Catches sessions whose owner died without a clean reboot (OOM, scaled-down pod).
+ * 1. **Own-instance recovery ({@link RunStartupRecovery})** — run once at boot. Closes any `Active`/`Idle`
+ *    session whose `HostInstanceID` belongs to an *earlier* boot of *this* MJAPI instance (same host and port,
+ *    different boot; see {@link HostInstanceIdentity}). Another MJAPI on the same host serves on another port,
+ *    so its live sessions are left alone. Primary defense against the "Active forever" leak after a restart.
+ * 2. **Global staleness sweep ({@link RunStalenessSweep})** — run on every periodic tick, on every
+ *    instance. Closes any `Active`/`Idle` session whose `LastActiveAt` is older than
+ *    `closeThresholdMinutes`, regardless of host. Catches sessions whose owner died without a clean
+ *    reboot (OOM, scaled-down pod).
+ * 3. **Max-duration sweep ({@link RunMaxDurationSweep})** — run on every periodic tick after the
+ *    staleness sweep. Closes any session past its stored hard deadline (the public voice cost cap).
+ *
+ * The close sweeps stamp `CloseReason = 'Janitor'`. A shutdown-time path — {@link RunShutdownDrain},
+ * invoked from {@link Shutdown} during the graceful ShutdownRegistry drain — closes this exact host
+ * instance's own live sessions with `CloseReason = 'Shutdown'`.
  *
- * Both sweeps stamp `CloseReason = 'Janitor'`. A third, shutdown-time path —
- * {@link RunShutdownDrain}, invoked from {@link Shutdown} during the graceful ShutdownRegistry
- * drain — closes this exact host instance's own live sessions with `CloseReason = 'Shutdown'`.
+ * Separately from closing, {@link RunRecordingRecoverySweep} runs after the close sweeps on every
+ * periodic tick, without blocking them, and rebuilds the recording of already-`Closed` sessions whose
+ * end-of-call upload never arrived (it closes nothing).
  *
- * Both sweeps are **idempotent and safe to run concurrently** on every instance: closing an
- * already-`Closed` session is a no-op, and the close path is last-writer-wins. Both page with keyset
+ * The close sweeps are **idempotent and safe to run concurrently** on every instance: closing an
+ * already-`Closed` session is a no-op, and the close path is last-writer-wins. Recording recovery is not
+ * strictly so: two instances can recover the same session at once (there is no claim column). Each
+ * attempt uploads its own file and defers to an already-stamped recording on a best-effort basis, so
+ * the cost is duplicate work and an extra file, not a lost recording. The extra file is an orphan when the
+ * second attempt's re-check sees the first stamp; when both re-checks pass first, both files are stamped in
+ * turn and both are linked to the session (the later stamp wins `RecordingFileID`). Every sweep pages with keyset
  * (`AfterKey`) pagination per the deep-pagination guide so a large backlog can't blow up memory.
  */
 export declare class SessionJanitor extends BaseSingleton<SessionJanitor> implements IShutdownable {
     private _config;
     private _sweepTimer;
     private _sweepRunning;
+    /**
+     * The in-flight recording recovery pass, or null. Separate from {@link _sweepRunning}: slow recovery
+     * must never block the close sweeps. Kept as a promise so {@link Shutdown} can wait for it.
+     */
+    private _recoveryPass;
+    /** Set by {@link Stop}, cleared by {@link Start}: no new recovery pass starts while stopped. */
+    private _stopped;
     private _registered;
     private _provider;
     private _systemUser;
     private readonly sessionManager;
+    /** Recovery retry state keyed by lowercase session id. Process-local: a restart gets fresh attempts. */
+    private readonly recoveryBackoff;
+    /**
+     * Lowercase ids of sessions whose recovery attempt timed out but has not settled. Skipped by later
+     * sweeps so a second attempt never runs alongside the abandoned one; removed when it settles.
+     */
+    private readonly abandonedRecoveries;
+    /** True once the "recovery paused" error has been logged for the current pause; reset when it lifts. */
+    private _recoveryPauseLogged;
     protected constructor();
     /** Process-wide singleton accessor (Global Object Store backed via {@link BaseSingleton}). */
     static get Instance(): SessionJanitor;
     /** Identifier surfaced in graceful-shutdown logs. */
     readonly ShutdownName = "SessionJanitor";
-    /** Overrides default tuning. Safe to call before or after {@link Start}. */
+    /**
+     * Overrides default tuning. Safe to call before or after {@link Start}. Every value given must be a
+     * finite number greater than zero: a NaN or non-positive duration would otherwise build an invalid
+     * cutoff date and make every later sweep throw. All-or-nothing: on an invalid value it throws, naming
+     * the field and value, and applies nothing. `undefined` values are ignored.
+     */
     Configure(config: Partial<SessionJanitorConfig>): void;
     /**
-     * Run own-host startup recovery once, then schedule the periodic staleness sweep. Idempotent:
-     * a second call does not stack a second timer. Captures the provider + system user so the timer
-     * callback can run without re-supplying them.
+     * Run own-host startup recovery once, then schedule the periodic tick (staleness and max-duration
+     * close sweeps, then recording recovery). Idempotent: a second call does not stack a second timer.
+     * Captures the provider + system user so the timer callback can run without re-supplying them, and
+     * re-enables recording recovery after a {@link Stop}. Throws, before doing any work, when
+     * `intervalMs` is invalid (see {@link Configure}).
      */
     Start(provider: IMetadataProvider, systemUser: UserInfo, intervalMs?: number): Promise<void>;
-    /** Stops the periodic sweep timer. Idempotent. Part of {@link IShutdownable}. */
+    /**
+     * Stops the periodic tick and keeps any new recording recovery pass from starting until the next
+     * {@link Start}, including one a tick already in progress would have started. A pass that is already
+     * running is not interrupted ({@link Shutdown} waits for it). Idempotent. Part of {@link IShutdownable}.
+     */
     Stop(): void;
     /**
-     * {@link IShutdownable}: clear the timer, then drain this host's own live sessions so a
-     * graceful stop never strands `Active`/`Idle` rows for the next boot's janitor to mop up.
+     * {@link IShutdownable}: stop the timer, then drain this host's own live sessions so a
+     * graceful stop never strands `Active`/`Idle` rows for the next boot's janitor to mop up, then wait
+     * (at most {@link RECOVERY_SHUTDOWN_WAIT_MS}) for an in-flight recording recovery pass.
      * Drained sessions are stamped `CloseReason = 'Shutdown'` (vs. `'Janitor'` for crash orphans),
      * so the dashboards can tell a clean redeploy from a reconciled crash. Never throws; the drain
      * is skipped when {@link Start} was never called (no captured provider/user).
@@ -69,10 +125,16 @@ export declare class SessionJanitor extends BaseSingleton<SessionJanitor> implem
      */
     RunShutdownDrain(provider: IMetadataProvider, systemUser: UserInfo): Promise<number>;
     /**
-     * Force-close any `Active`/`Idle` session left behind by a *previous boot of this host*
-     * (matching hostname prefix, differing `bootId`). Returns the number of sessions closed.
+     * Force-close any `Active`/`Idle` session left behind by an earlier boot of this MJAPI instance: its
+     * `HostInstanceID` has this instance's prefix (`hostname:port:`) and another boot. The sessions of another
+     * MJAPI on the same host carry another port and stay open. Returns the number of sessions closed.
+     *
+     * @param provider The metadata provider for the reads and writes.
+     * @param systemUser The user the closes run as.
+     * @param hostInstance The instance whose earlier boots to close. Defaults to this process's
+     *   ({@link GetCurrentHostInstance}).
      */
-    RunStartupRecovery(provider: IMetadataProvider, systemUser: UserInfo): Promise<number>;
+    RunStartupRecovery(provider: IMetadataProvider, systemUser: UserInfo, hostInstance?: HostInstanceIdentity): Promise<number>;
     /**
      * Force-close any `Active`/`Idle` session whose `LastActiveAt` is older than the configured
      * close threshold, regardless of host. Idempotent and concurrency-safe. Returns the count closed.
@@ -89,14 +151,87 @@ export declare class SessionJanitor extends BaseSingleton<SessionJanitor> implem
      * `CloseReason = 'Janitor'`, idempotent + concurrency-safe like the other sweeps. Returns the count closed.
      */
     RunMaxDurationSweep(provider: IMetadataProvider, systemUser: UserInfo): Promise<number>;
+    /**
+     * Rebuilds the recording of sessions whose end-of-call upload never arrived (browser died, tab
+     * closed). A session is a candidate when it is `Closed`, has `RecordingStartedAt` (consent is implied:
+     * recording only starts after the guest agreed), still has no `RecordingFileID`, and closed between
+     * the lookback window and the grace period (see {@link SessionJanitorConfig.recordingRecoveryGraceMinutes}).
+     *
+     * Work is bounded: candidates are handled sequentially, at most {@link MAX_RECOVERIES_PER_SWEEP}
+     * recovery attempts per call, and a failing session backs off exponentially (`min(2^k * 5 min, 6 h)`)
+     * and is abandoned after {@link MAX_RECOVERY_ATTEMPTS} failures with one `LogError`. Backoff entries of
+     * sessions that left the candidate set are pruned, but only after a pass that saw every candidate, so
+     * a capped pass never forgets sessions it did not reach.
+     *
+     * Never throws for a single bad session. Returns the number of recordings recovered.
+     */
+    RunRecordingRecoverySweep(provider: IMetadataProvider, systemUser: UserInfo): Promise<number>;
     /** Parses the absolute deadline (ms) from a session's `Config_` JSON, or null when absent/malformed. */
     private parseSessionDeadlineMs;
     /** Register for graceful shutdown exactly once. */
     private ensureRegistered;
-    /** Schedule the periodic staleness sweep, exactly once. Timer is unref'd so it never blocks exit. */
+    /** Schedule the periodic sweep tick (close sweeps + recording recovery), exactly once. Timer is unref'd so it never blocks exit. */
     private scheduleSweep;
-    /** Timer tick: run the staleness sweep under the captured provider/user, guarding overlap. */
+    /**
+     * Timer tick: run the close sweeps (staleness, then max-duration) under the captured
+     * provider/user, guarding overlap, then kick off recording recovery.
+     *
+     * Recovery is started WITHOUT awaiting and has its own overlap guard: it can spend minutes on
+     * large downloads/uploads, and awaiting it under the close sweeps' guard would delay the
+     * max-duration cost cap and make every later tick return early. Each tick skips recovery while a pass
+     * is still running; because every session's attempt is bounded by
+     * `recordingRecoveryAttemptTimeoutMinutes`, a hung storage call delays later passes, never stops them.
+     */
     private periodicSweep;
+    /**
+     * Fire-and-forget recording recovery, skipped when the previous pass is still running or the janitor
+     * has been stopped (a tick that was mid-close-sweep when {@link Stop} ran must not start one).
+     */
+    private startRecoveryPass;
+    /**
+     * Waits for the in-flight recovery pass, if any, for at most {@link RECOVERY_SHUTDOWN_WAIT_MS}; logs
+     * once when it gives up. Never throws: the pass promise already logs and absorbs its own errors.
+     */
+    private waitForRecoveryPass;
+    /**
+     * Recovers one candidate's recording and updates its backoff. Never throws: any exception is logged
+     * with the session id and counted as a failure.
+     */
+    private recoverSessionRecording;
+    /**
+     * Runs one session's recovery, giving up on waiting after `recordingRecoveryAttemptTimeoutMinutes`.
+     * A call cannot be cancelled, so a timed-out one keeps running: the session is marked abandoned until
+     * it settles (later sweeps skip it), and its late outcome is logged then.
+     */
+    private recoverWithinTimeout;
+    /**
+     * True while {@link MAX_ABANDONED_RECOVERIES} timed-out attempts are still running: no new attempt
+     * starts until one settles. Logs one `LogError` per pause.
+     */
+    private isRecoveryPausedForAbandonedAttempts;
+    /**
+     * Defers a session that cannot be recovered until configuration changes (its agent has no recording
+     * storage account). That is not a failed attempt, so it never counts toward the give-up: the session
+     * is re-checked every {@link RECOVERY_BACKOFF_MAX_MS} and logged only the first time.
+     */
+    private deferRecovery;
+    /**
+     * Loads the agent carrying a session's recording storage config and resolves its storage account,
+     * memoized per agent for the sweep: the resolve may force a storage-engine reload, so it must not
+     * repeat for every session of the same agent.
+     */
+    private resolveRecoveryStorage;
+    /** True while a session's backoff (or give-up) window has not elapsed. */
+    private isRecoveryBackedOff;
+    /**
+     * Counts one more unsuccessful recovery for a session and schedules its next attempt
+     * (`min(2^k * 5 min, 6 h)`); at {@link MAX_RECOVERY_ATTEMPTS} it stops checking the session for this
+     * process with a single log line: a `LogError` when the last attempt failed, a `LogStatus` when it
+     * simply found no shards (nothing to recover is not an error).
+     */
+    private recordRecoveryFailure;
+    /** Drops backoff state for sessions that were not in the latest complete candidate set. */
+    private pruneRecoveryBackoff;
     /**
      * Page through every session matching `filter` with keyset (`AfterKey`) pagination and close each
      * via {@link SessionManager.CloseSession}, stamping `closeReason` on every row it transitions.
@@ -104,6 +239,19 @@ export declare class SessionJanitor extends BaseSingleton<SessionJanitor> implem
      * harmless no-op that keeps its original reason.
      */
     private sweepAndClose;
+    /**
+     * Keyset-page (`AfterKey`) through every session matching `filter`, handing each full fetched page
+     * to `visit`. Stops on a load failure (already logged), an empty page, a partial page, or when
+     * `visit` returns `false`.
+     *
+     * `visit` receives the page exactly as the SQL filter matched it. The keyset advances from the
+     * LAST FETCHED row, so any narrowing `visit` does in JS can never stall or skip pagination.
+     *
+     * Returns how the walk ended: `'complete'` (reached the end of the matching set), `'stopped'`
+     * (`visit` returned `false`) or `'failed'` (a page failed to load). Callers that reason about the
+     * WHOLE set (e.g. pruning state for absent rows) must act only on `'complete'`.
+     */
+    private forEachSessionPage;
     /** Fetch one keyset page of matching sessions, or null on a load failure (logged). */
     private fetchPage;
 }

package/dist/agentSessions/SessionJanitor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SessionJanitor.d.ts","sourceRoot":"","sources":["../../src/agentSessions/SessionJanitor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAoB,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACxF,OAAO,EACH,iBAAiB,EACjB,QAAQ,EAMX,MAAM,sBAAsB,CAAC;AAW9B,wEAAwE;AACxE,MAAM,WAAW,oBAAoB;IACjC,0GAA0G;IAC1G,qBAAqB,EAAE,MAAM,CAAC;IAC9B,+FAA+F;IAC/F,eAAe,EAAE,MAAM,CAAC;CAC3B;AAOD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,cAAe,SAAQ,aAAa,CAAC,cAAc,CAAE,YAAW,aAAa;IACtF,OAAO,CAAC,OAAO,CAAwC;IACvD,OAAO,CAAC,WAAW,CAA+C;IAClE,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,SAAS,CAAkC;IACnD,OAAO,CAAC,WAAW,CAAyB;IAC5C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAwB;IAEvD,SAAS;IAIT,8FAA8F;IAC9F,WAAkB,QAAQ,IAAI,cAAc,CAE3C;IAED,qDAAqD;IACrD,SAAgB,YAAY,oBAAoB;IAEhD,4EAA4E;IACrE,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,oBAAoB,CAAC,GAAG,IAAI;IAI7D;;;;OAIG;IACU,KAAK,CAAC,QAAQ,EAAE,iBAAiB,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAWzG,iFAAiF;IAC1E,IAAI,IAAI,IAAI;IAOnB;;;;;;OAMG;IACU,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAWtC;;;;;OAKG;IACU,gBAAgB,CAAC,QAAQ,EAAE,iBAAiB,EAAE,UAAU,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC;IAUjG;;;OAGG;IACU,kBAAkB,CAAC,QAAQ,EAAE,iBAAiB,EAAE,UAAU,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC;IAcnG;;;OAGG;IACU,iBAAiB,CAAC,QAAQ,EAAE,iBAAiB,EAAE,UAAU,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC;IAUlG;;;;;;;;;OASG;IACU,mBAAmB,CAAC,QAAQ,EAAE,iBAAiB,EAAE,UAAU,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC;IAgBpG,wGAAwG;IACxG,OAAO,CAAC,sBAAsB;IAkB9B,mDAAmD;IACnD,OAAO,CAAC,gBAAgB;IAOxB,qGAAqG;IACrG,OAAO,CAAC,aAAa;IAQrB,8FAA8F;YAChF,aAAa;IAiB3B;;;;;OAKG;YACW,aAAa;IA4D3B,sFAAsF;YACxE,SAAS;CAqB1B"}
+{"version":3,"file":"SessionJanitor.d.ts","sourceRoot":"","sources":["../../src/agentSessions/SessionJanitor.ts"],"names":[],"mappings":"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"}