@forestadmin/agent-bff 1.31.0 → 1.32.0

package/dist/action/action-routes-middleware.d.ts

@@ -1,4 +1,5 @@
 import type { AgentActionClient, AgentActionClientOptions } from './agent-action-client';
+import type { ActivityLogWriter } from '../activity-log/activity-log-writer';
 import type { AgentTransport } from '../agent/agent-transport';
 import type { Logger } from '../ports/logger-port';
 import type ReadModelStore from '../read-model/read-model-store';
@@ -7,7 +8,8 @@ export interface ActionRoutesMiddlewareOptions {
     store: ReadModelStore;
     transport: AgentTransport;
     logger: Logger;
+    activityLogs: ActivityLogWriter;
     createClient?: (options: AgentActionClientOptions) => AgentActionClient;
 }
-export default function createActionRoutesMiddleware({ store, transport, logger, createClient, }: ActionRoutesMiddlewareOptions): Middleware;
+export default function createActionRoutesMiddleware({ store, transport, logger, activityLogs, createClient, }: ActionRoutesMiddlewareOptions): Middleware;
 //# sourceMappingURL=action-routes-middleware.d.ts.map

package/dist/action/action-routes-middleware.js

@@ -45,8 +45,19 @@ const agent_action_client_1 = __importStar(require("./agent-action-client"));
 const sanitize_action_html_1 = __importDefault(require("./sanitize-action-html"));
 const agent_error_mapper_1 = require("../http/agent-error-mapper");
 const agent_route_helpers_1 = require("../http/agent-route-helpers");
+const bff_http_error_1 = require("../http/bff-http-error");
 const bff_local_errors_1 = require("../http/bff-local-errors");
 const ACTION_ROUTE = /^\/agent\/v1\/([^/]+)\/actions\/([^/]+)\/(form|execute)$/;
+const EXECUTE_VERB = 'execute';
+/**
+ * An approval request is a business outcome, not a failure: the action was routed for review. The
+ * BFF answers it with a 403, but recording the entry as `failed` would make the same event count
+ * differently here and in mcp-server, which records it as a success — and action-failure statistics
+ * would mix refusals with runs that never happened.
+ */
+function isApprovalRequest(error) {
+    return error instanceof bff_http_error_1.BffHttpError && error.type === bff_local_errors_1.ACTION_REQUIRES_APPROVAL_TYPE;
+}
 // recordIds are opaque BFF ids; only presence and array-ness are checked. An empty array is allowed
 // on purpose (global/bulk actions have no selected records); the spec AC only covers a missing
 // recordIds, so `[]` is an explicit BFF choice, not a spec requirement.
@@ -148,7 +159,7 @@ async function handleExecute({ ctx, action, values, logger, }) {
     ctx.status = status;
     ctx.body = body;
 }
-function createActionRoutesMiddleware({ store, transport, logger, createClient = agent_action_client_1.default, }) {
+function createActionRoutesMiddleware({ store, transport, logger, activityLogs, createClient = agent_action_client_1.default, }) {
     return async function actionRoutesMiddleware(ctx, next) {
         const match = ACTION_ROUTE.exec(ctx.path);
         if (!match || ctx.method !== 'POST') {
@@ -162,12 +173,15 @@ function createActionRoutesMiddleware({ store, transport, logger, createClient =
         const readModel = await (0, agent_route_helpers_1.resolveReadModel)(store);
         // The read-model's action map IS the allow-list, so an absent action cannot be told from a
         // known-but-disallowed one — every non-exposed action maps to 404 here; `action_not_allowed`
-        // (403) has no local trigger, mirroring `collection_not_allowed`/`relation_not_allowed`. The
-        // URL identity is resolved before the body, so a bad action 404s before its payload is read.
+        // (403) has no local trigger, mirroring `collection_not_allowed`/`relation_not_allowed`.
         // TODO(PRD-673): distinguish disallowed from unknown when a separate exposure source exists.
-        if (!readModel.isActionAllowed(collection, actionName)) {
+        const allowed = readModel.isActionAllowed(collection, actionName);
+        const refuseUnknownAction = () => {
             throw (0, bff_local_errors_1.unknownAction)(`Unknown action: ${collection}.${actionName}`);
-        }
+        };
+        // The form is unaudited, so it keeps refusing before the body is read.
+        if (!allowed && verb !== EXECUTE_VERB)
+            refuseUnknownAction();
         const body = (ctx.request.body ?? {});
         assertKnownBodyKeys(body);
         const recordIds = parseRecordIds(body.recordIds);
@@ -177,19 +191,40 @@ function createActionRoutesMiddleware({ store, transport, logger, createClient =
             token,
             actionEndpoints: readModel.getActionEndpoints(),
         });
-        const action = await (0, agent_route_helpers_1.callAgent)(() => client.loadAction({
+        const loadAction = () => (0, agent_route_helpers_1.callAgent)(() => client.loadAction({
             collection,
             actionName,
             recordIds,
             timezone: ctx.state.timezone,
         }), logger);
-        const handlerArgs = { ctx, action, values, logger };
-        if (verb === 'execute') {
-            await handleExecute(handlerArgs);
-        }
-        else {
-            await handleForm(handlerArgs);
+        // The form is not audited, mirroring mcp-server, whose get-action-form tool writes no log
+        // either: the record-touching event the trail records is the execution.
+        if (verb !== EXECUTE_VERB) {
+            const action = await loadAction();
+            await handleForm({ ctx, action, values, logger });
+            return;
         }
+        // The whole sequence is audited, loadAction and setFields included, so the intent is recorded
+        // even when the attempt never reaches the agent's execute. The allow-list refusal is inside
+        // too, mirroring mcp-server, whose execute-action tool resolves the action within its own
+        // wrapper: an attempt on an action the caller may not trigger is exactly what the trail is
+        // for, and the record ids it names are only known once the body is read.
+        await activityLogs.record({
+            ctx,
+            action: 'action',
+            context: {
+                collectionName: collection,
+                recordIds,
+                label: `triggered the action "${actionName}"`,
+            },
+            isCompletedDespite: isApprovalRequest,
+            operation: async () => {
+                if (!allowed)
+                    refuseUnknownAction();
+                const action = await loadAction();
+                await handleExecute({ ctx, action, values, logger });
+            },
+        });
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action-routes-middleware.js","sourceRoot":"","sources":["../../src/action/action-routes-middleware.ts"],"names":[],"mappings":"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"}

package/dist/activity-log/activity-log-drainer.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Holds the audited requests and the status transitions they fire without `await`. Nothing else
+ * keeps the transitions alive: `server.close()` waits for connections, and one sent after the
+ * response is attached to none — without this, every deploy would leave entries stuck in `pending`.
+ *
+ * The requests are tracked too, and not only their transitions, for the embedded deployment: there
+ * the host owns the connections, so `stop()` returns while requests are still running and their
+ * transitions are not registered yet.
+ */
+export default class ActivityLogDrainer {
+    private readonly inFlight;
+    track<T>(operation: () => Promise<T>, description: string): Promise<T>;
+    /**
+     * Loops rather than settling one snapshot: a transition is registered only once the request it
+     * audits has finished, so a single pass would return before the work that outlives it.
+     *
+     * `timeoutMs` is the shutdown deadline the caller shares: a stalled audit store would otherwise
+     * hold the process past the grace its orchestrator gives it, and be SIGKILLed mid-drain. Returns
+     * what the deadline left unfinished, empty when everything settled.
+     */
+    drain(timeoutMs?: number): Promise<string[]>;
+    private settle;
+}
+//# sourceMappingURL=activity-log-drainer.d.ts.map

package/dist/activity-log/activity-log-drainer.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Holds the audited requests and the status transitions they fire without `await`. Nothing else
+ * keeps the transitions alive: `server.close()` waits for connections, and one sent after the
+ * response is attached to none — without this, every deploy would leave entries stuck in `pending`.
+ *
+ * The requests are tracked too, and not only their transitions, for the embedded deployment: there
+ * the host owns the connections, so `stop()` returns while requests are still running and their
+ * transitions are not registered yet.
+ */
+class ActivityLogDrainer {
+    constructor() {
+        this.inFlight = new Set();
+    }
+    track(operation, description) {
+        const promise = operation();
+        const entry = { promise, description };
+        this.inFlight.add(entry);
+        promise.finally(() => this.inFlight.delete(entry)).catch(() => { });
+        return promise;
+    }
+    /**
+     * Loops rather than settling one snapshot: a transition is registered only once the request it
+     * audits has finished, so a single pass would return before the work that outlives it.
+     *
+     * `timeoutMs` is the shutdown deadline the caller shares: a stalled audit store would otherwise
+     * hold the process past the grace its orchestrator gives it, and be SIGKILLed mid-drain. Returns
+     * what the deadline left unfinished, empty when everything settled.
+     */
+    async drain(timeoutMs) {
+        const deadline = timeoutMs === undefined ? undefined : Date.now() + timeoutMs;
+        while (this.inFlight.size > 0) {
+            const remainingMs = deadline === undefined ? undefined : deadline - Date.now();
+            if (remainingMs !== undefined && remainingMs <= 0)
+                break;
+            // eslint-disable-next-line no-await-in-loop
+            await this.settle(remainingMs);
+        }
+        return [...this.inFlight].map(entry => entry.description);
+    }
+    async settle(timeoutMs) {
+        const settled = Promise.allSettled([...this.inFlight].map(entry => entry.promise));
+        if (timeoutMs === undefined) {
+            await settled;
+            return;
+        }
+        let timer;
+        try {
+            await Promise.race([
+                settled,
+                new Promise(resolve => {
+                    timer = setTimeout(resolve, timeoutMs);
+                }),
+            ]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+exports.default = ActivityLogDrainer;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/activity-log/activity-log-writer.d.ts

@@ -0,0 +1,26 @@
+import type { ActivityLogContext, BffActivityLogAction } from './activity-logs-creator';
+import type { ActivityLogsWriter } from './activity-logs-service';
+import type { Logger } from '../ports/logger-port';
+import type { Context } from 'koa';
+export interface RecordActivityLogOptions<T> {
+    ctx: Context;
+    action: BffActivityLogAction;
+    context?: ActivityLogContext;
+    operation: () => Promise<T>;
+    isCompletedDespite?: (error: unknown) => boolean;
+}
+export interface ActivityLogWriter {
+    record<T>(options: RecordActivityLogOptions<T>): Promise<T>;
+    /**
+     * Waits for the audited requests still running and for the status transitions no connection
+     * holds. Called when the server stops, which shares its deadline through `timeoutMs`; returns
+     * the operations that deadline left unfinished.
+     */
+    drain(timeoutMs?: number): Promise<string[]>;
+}
+export interface ActivityLogWriterOptions {
+    service: ActivityLogsWriter;
+    logger: Logger;
+}
+export default function createActivityLogWriter({ service, logger, }: ActivityLogWriterOptions): ActivityLogWriter;
+//# sourceMappingURL=activity-log-writer.d.ts.map

package/dist/activity-log/activity-log-writer.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createActivityLogWriter;
+const activity_log_drainer_1 = __importDefault(require("./activity-log-drainer"));
+const with_activity_log_1 = __importDefault(require("./with-activity-log"));
+function describeRequest(action, collectionName) {
+    return collectionName ? `'${action}' request on '${collectionName}'` : `'${action}' request`;
+}
+function createActivityLogWriter({ service, logger, }) {
+    const drainer = new activity_log_drainer_1.default();
+    return {
+        record(options) {
+            return drainer.track(() => (0, with_activity_log_1.default)({ ...options, service, drainer, logger }), describeRequest(options.action, options.context?.collectionName));
+        },
+        drain(timeoutMs) {
+            return drainer.drain(timeoutMs);
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aXZpdHktbG9nLXdyaXRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hY3Rpdml0eS1sb2cvYWN0aXZpdHktbG9nLXdyaXRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQW1DQSwwQ0FrQkM7QUFoREQsa0ZBQXdEO0FBQ3hELDRFQUFrRDtBQXlCbEQsU0FBUyxlQUFlLENBQUMsTUFBNEIsRUFBRSxjQUF1QjtJQUM1RSxPQUFPLGNBQWMsQ0FBQyxDQUFDLENBQUMsSUFBSSxNQUFNLGlCQUFpQixjQUFjLEdBQUcsQ0FBQyxDQUFDLENBQUMsSUFBSSxNQUFNLFdBQVcsQ0FBQztBQUMvRixDQUFDO0FBRUQsU0FBd0IsdUJBQXVCLENBQUMsRUFDOUMsT0FBTyxFQUNQLE1BQU0sR0FDbUI7SUFDekIsTUFBTSxPQUFPLEdBQUcsSUFBSSw4QkFBa0IsRUFBRSxDQUFDO0lBRXpDLE9BQU87UUFDTCxNQUFNLENBQUksT0FBb0M7WUFDNUMsT0FBTyxPQUFPLENBQUMsS0FBSyxDQUNsQixHQUFHLEVBQUUsQ0FBQyxJQUFBLDJCQUFlLEVBQUMsRUFBRSxHQUFHLE9BQU8sRUFBRSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxDQUFDLEVBQy9ELGVBQWUsQ0FBQyxPQUFPLENBQUMsTUFBTSxFQUFFLE9BQU8sQ0FBQyxPQUFPLEVBQUUsY0FBYyxDQUFDLENBQ2pFLENBQUM7UUFDSixDQUFDO1FBRUQsS0FBSyxDQUFDLFNBQWtCO1lBQ3RCLE9BQU8sT0FBTyxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUNsQyxDQUFDO0tBQ0YsQ0FBQztBQUNKLENBQUMifQ==

package/dist/activity-log/activity-logs-creator.d.ts

@@ -0,0 +1,42 @@
+import type ActivityLogDrainer from './activity-log-drainer';
+import type { ActivityLogsWriter } from './activity-logs-service';
+import type { Logger } from '../ports/logger-port';
+import type { ActivityLogAction, ActivityLogResponse } from '@forestadmin/forestadmin-client';
+import type { Context } from 'koa';
+/** The actions the BFF writes: its data routes read, and its action route writes. */
+export type BffActivityLogAction = Extract<ActivityLogAction, 'index' | 'search' | 'filter' | 'listRelatedData' | 'action'>;
+export interface ActivityLogContext {
+    collectionName?: string;
+    recordId?: string | number;
+    recordIds?: string[] | number[];
+    label?: string;
+}
+/**
+ * The token that created the log is kept for the status transition: the transition is fired after
+ * the response, when the session it came from may already be unreachable.
+ */
+export interface PendingActivityLog {
+    activityLog: ActivityLogResponse;
+    forestServerToken: string;
+}
+export interface CreatePendingActivityLogOptions {
+    ctx: Context;
+    service: ActivityLogsWriter;
+    action: BffActivityLogAction;
+    context?: ActivityLogContext;
+    logger: Logger;
+}
+export default function createPendingActivityLog({ ctx, service, action, context, logger, }: CreatePendingActivityLogOptions): Promise<PendingActivityLog | null>;
+export interface MarkActivityLogOptions {
+    service: ActivityLogsWriter;
+    drainer: ActivityLogDrainer;
+    pending: PendingActivityLog;
+    status: 'completed' | 'failed';
+    logger: Logger;
+}
+/**
+ * Fire-and-forget on purpose: the caller's response must not wait for the audit store. The drainer
+ * holds the promise so a shutdown can wait for it instead.
+ */
+export declare function markActivityLog(options: MarkActivityLogOptions): void;
+//# sourceMappingURL=activity-logs-creator.d.ts.map

package/dist/activity-log/activity-logs-creator.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createPendingActivityLog;
+exports.markActivityLog = markActivityLog;
+const forestadmin_client_1 = require("@forestadmin/forestadmin-client");
+const api_key_middleware_1 = require("../api-key/api-key-middleware");
+const forest_server_token_middleware_1 = require("../auth/forest-server-token-middleware");
+const bff_http_error_1 = require("../http/bff-http-error");
+const bff_local_errors_1 = require("../http/bff-local-errors");
+/**
+ * Fail policy for the audit trail, keyed by action type: a write whose activity log cannot be
+ * created is blocked (no unaudited side effect), while a read proceeds with a warning (an audit
+ * store outage must not take down the read surface).
+ *
+ * One case is arbitrated by the cause instead of the action type: an authorization refusal (403)
+ * propagates for reads too — the read itself is not authorized either.
+ */
+const ACTION_TO_TYPE = {
+    index: 'read',
+    search: 'read',
+    filter: 'read',
+    listRelatedData: 'read',
+    action: 'write',
+};
+const MAX_STATUS_ATTEMPTS = 5;
+const STATUS_RETRY_DELAY_MS = 500;
+const NO_RENDERING_MESSAGE = 'This request carries no usable rendering';
+function describeCause(error) {
+    return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+}
+const FORBIDDEN = 403;
+const UNAUTHORIZED = 401;
+const SERVER_ERROR = 500;
+/** Not found: the document may not be visible yet. 0: unreachable. 408: timeout. 429: throttled. */
+const RETRYABLE_TRANSITION_STATUSES = new Set([0, 404, 408, 429]);
+const AUDIT_ENDPOINT_ABSENT_STATUSES = new Set([404, 501]);
+const NO_AUDIT_ENDPOINT_MESSAGE = 'The Forest server does not expose the endpoint the activity log is written through, so the ' +
+    'operation was not performed';
+/**
+ * A 403 only. A 401 is not the caller being refused: the bearer the BFF audits with is minted by
+ * the Forest server and cached, so a 401 says that token expired — answering the caller with
+ * `audit_not_authorized` would refuse a read the fail-open policy lets through.
+ */
+function isAuthorizationRefusal(error) {
+    return error instanceof forestadmin_client_1.HttpError && error.status === FORBIDDEN;
+}
+function isExpiredAuditCredential(error) {
+    return error instanceof forestadmin_client_1.HttpError && error.status === UNAUTHORIZED;
+}
+/**
+ * A Forest server that does not serve the activity-log endpoint at all, rather than one failing to
+ * answer it. No retry can make the route appear, so the caller must not be handed a `Retry-After`
+ * it would keep honouring on every write.
+ */
+function isAuditEndpointAbsent(error) {
+    return error instanceof forestadmin_client_1.HttpError && AUDIT_ENDPOINT_ABSENT_STATUSES.has(error.status);
+}
+/**
+ * What locates the failure for support, and nothing else: the credential, the record ids and the
+ * label are the payload this must never carry.
+ */
+function auditIdentifiers(ctx, context) {
+    const renderingId = (0, forest_server_token_middleware_1.resolveRenderingId)(ctx);
+    return {
+        ...(renderingId === undefined ? {} : { renderingId }),
+        ...(context?.collectionName === undefined ? {} : { collectionName: context.collectionName }),
+    };
+}
+/** An empty string is an answer, not a value: it locates no document, so it fails the guard. */
+function isPresent(value) {
+    return value !== null && value !== undefined && value !== '';
+}
+/**
+ * The status transition reads both the id and the index, so an answer carrying only an id strands
+ * the entry `pending`: the fail-closed policy has to engage here, not asynchronously afterwards.
+ */
+function isTransitionable(activityLog) {
+    return isPresent(activityLog?.id) && isPresent(activityLog?.attributes?.index);
+}
+/**
+ * A credential this deployment never mints is a degradation the Forest server declares by sending
+ * none (`api-key/api-key-client.ts`), so it warns; only a resolution that actually failed is an
+ * error. The single report for either: `with-activity-log` states nothing of its own, which used to
+ * double every line of the read path.
+ */
+function reportUnresolvedCredentials({ ctx, action, context, logger, error, }) {
+    const identifiers = { ...auditIdentifiers(ctx, context), cause: describeCause(error) };
+    if ((0, bff_local_errors_1.isUnretryableAuditFailure)(error)) {
+        logger('Warn', `Activity log for '${action}' was not created: this deployment has no credential to write ` +
+            'it with', identifiers);
+        return;
+    }
+    logger('Error', `Activity log for '${action}' has no credentials to be created with`, identifiers);
+}
+async function resolveCredentials(ctx) {
+    const renderingId = (0, forest_server_token_middleware_1.resolveRenderingId)(ctx);
+    if (renderingId === undefined)
+        throw (0, bff_http_error_1.sessionExpired)(NO_RENDERING_MESSAGE);
+    return {
+        forestServerToken: await (0, forest_server_token_middleware_1.resolveForestServerToken)(ctx),
+        renderingId: String(renderingId),
+    };
+}
+async function createPendingActivityLog({ ctx, service, action, context, logger, }) {
+    const type = ACTION_TO_TYPE[action];
+    let credentials;
+    try {
+        credentials = await resolveCredentials(ctx);
+    }
+    catch (error) {
+        reportUnresolvedCredentials({ ctx, action, context, logger, error });
+        if (type === 'write')
+            throw error;
+        return null;
+    }
+    const { forestServerToken, renderingId } = credentials;
+    let activityLog;
+    try {
+        activityLog = await service.createMcpActivityLog({
+            forestServerToken,
+            renderingId,
+            action,
+            type,
+            collectionName: context?.collectionName,
+            recordId: context?.recordId,
+            recordIds: context?.recordIds,
+            label: context?.label,
+        });
+    }
+    catch (error) {
+        logger('Error', `Activity log for '${action}' could not be created`, {
+            ...auditIdentifiers(ctx, context),
+            cause: describeCause(error),
+        });
+        if (isAuthorizationRefusal(error))
+            throw (0, bff_local_errors_1.auditNotAuthorized)();
+        if (isExpiredAuditCredential(error))
+            (0, api_key_middleware_1.invalidateApiKeyIdentity)(ctx);
+        if (type === 'write') {
+            throw isAuditEndpointAbsent(error)
+                ? (0, bff_local_errors_1.auditUnavailable)(undefined, NO_AUDIT_ENDPOINT_MESSAGE)
+                : (0, bff_local_errors_1.auditUnavailable)(bff_local_errors_1.AUDIT_RETRY_AFTER_SECONDS);
+        }
+        return null;
+    }
+    if (!isTransitionable(activityLog)) {
+        logger('Error', `Activity log for '${action}' could not be created: the server answered with no activity ` +
+            'log id or index, so the audit store dropped the write', auditIdentifiers(ctx, context));
+        if (type === 'write')
+            throw (0, bff_local_errors_1.auditUnavailable)(bff_local_errors_1.AUDIT_RETRY_AFTER_SECONDS);
+        return null;
+    }
+    return { activityLog, forestServerToken };
+}
+/**
+ * The transition is fired after the response, so nothing retries it downstream: an entry whose
+ * transition is dropped stays `pending` for good and skews the action-failure statistics. Retried
+ * are the failures a later attempt can land — the document not existing yet, a timeout, a throttle,
+ * an unreachable server (status 0) and any 5xx — plus a transport failure the client rethrows raw,
+ * which carries no status at all. A refusal or a malformed request is left to fail at once.
+ */
+function isRetryableTransitionFailure(error) {
+    if (!(error instanceof forestadmin_client_1.HttpError))
+        return true;
+    return error.status >= SERVER_ERROR || RETRYABLE_TRANSITION_STATUSES.has(error.status);
+}
+async function updateStatus(options, attempt = 1) {
+    const { service, pending, status, logger } = options;
+    try {
+        await service.updateActivityLogStatus({
+            forestServerToken: pending.forestServerToken,
+            activityLog: pending.activityLog,
+            status,
+        });
+    }
+    catch (error) {
+        if (isRetryableTransitionFailure(error) && attempt < MAX_STATUS_ATTEMPTS) {
+            logger('Debug', `Activity log status transition failed, retrying it`, {
+                attempt,
+                attempts: MAX_STATUS_ATTEMPTS,
+                cause: describeCause(error),
+            });
+            await new Promise(resolve => {
+                // Unreferenced: a pending retry must not outlive the shutdown grace the drainer enforces.
+                setTimeout(resolve, STATUS_RETRY_DELAY_MS).unref();
+            });
+            await updateStatus(options, attempt + 1);
+            return;
+        }
+        throw error;
+    }
+}
+/**
+ * Fire-and-forget on purpose: the caller's response must not wait for the audit store. The drainer
+ * holds the promise so a shutdown can wait for it instead.
+ */
+function markActivityLog(options) {
+    const { drainer, status, logger } = options;
+    drainer
+        .track(() => updateStatus(options), `'${status}' transition of the activity log ${options.pending.activityLog.id}`)
+        .catch(error => {
+        logger('Error', `Failed to mark the activity log as '${status}'`, {
+            activityLogId: options.pending.activityLog.id,
+            index: options.pending.activityLog.attributes?.index,
+            cause: describeCause(error),
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aXZpdHktbG9ncy1jcmVhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FjdGl2aXR5LWxvZy9hY3Rpdml0eS1sb2dzLWNyZWF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUF1TUEsMkNBb0VDO0FBMERELDBDQWVDO0FBMVVELHdFQUE0RDtBQUU1RCxzRUFBeUU7QUFDekUsMkZBR2dEO0FBQ2hELDJEQUF3RDtBQUN4RCwrREFLa0M7QUFRbEM7Ozs7Ozs7R0FPRztBQUNILE1BQU0sY0FBYyxHQUFrRDtJQUNwRSxLQUFLLEVBQUUsTUFBTTtJQUNiLE1BQU0sRUFBRSxNQUFNO0lBQ2QsTUFBTSxFQUFFLE1BQU07SUFDZCxlQUFlLEVBQUUsTUFBTTtJQUN2QixNQUFNLEVBQUUsT0FBTztDQUNoQixDQUFDO0FBRUYsTUFBTSxtQkFBbUIsR0FBRyxDQUFDLENBQUM7QUFDOUIsTUFBTSxxQkFBcUIsR0FBRyxHQUFHLENBQUM7QUFFbEMsTUFBTSxvQkFBb0IsR0FBRywwQ0FBMEMsQ0FBQztBQStCeEUsU0FBUyxhQUFhLENBQUMsS0FBYztJQUNuQyxPQUFPLEtBQUssWUFBWSxLQUFLLENBQUMsQ0FBQyxDQUFDLEdBQUcsS0FBSyxDQUFDLElBQUksS0FBSyxLQUFLLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQztBQUNwRixDQUFDO0FBRUQsTUFBTSxTQUFTLEdBQUcsR0FBRyxDQUFDO0FBQ3RCLE1BQU0sWUFBWSxHQUFHLEdBQUcsQ0FBQztBQUN6QixNQUFNLFlBQVksR0FBRyxHQUFHLENBQUM7QUFDekIsb0dBQW9HO0FBQ3BHLE1BQU0sNkJBQTZCLEdBQUcsSUFBSSxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsR0FBRyxFQUFFLEdBQUcsRUFBRSxHQUFHLENBQUMsQ0FBQyxDQUFDO0FBQ2xFLE1BQU0sOEJBQThCLEdBQUcsSUFBSSxHQUFHLENBQUMsQ0FBQyxHQUFHLEVBQUUsR0FBRyxDQUFDLENBQUMsQ0FBQztBQUUzRCxNQUFNLHlCQUF5QixHQUM3Qiw2RkFBNkY7SUFDN0YsNkJBQTZCLENBQUM7QUFFaEM7Ozs7R0FJRztBQUNILFNBQVMsc0JBQXNCLENBQUMsS0FBYztJQUM1QyxPQUFPLEtBQUssWUFBWSw4QkFBUyxJQUFJLEtBQUssQ0FBQyxNQUFNLEtBQUssU0FBUyxDQUFDO0FBQ2xFLENBQUM7QUFFRCxTQUFTLHdCQUF3QixDQUFDLEtBQWM7SUFDOUMsT0FBTyxLQUFLLFlBQVksOEJBQVMsSUFBSSxLQUFLLENBQUMsTUFBTSxLQUFLLFlBQVksQ0FBQztBQUNyRSxDQUFDO0FBRUQ7Ozs7R0FJRztBQUNILFNBQVMscUJBQXFCLENBQUMsS0FBYztJQUMzQyxPQUFPLEtBQUssWUFBWSw4QkFBUyxJQUFJLDhCQUE4QixDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUM7QUFDeEYsQ0FBQztBQUVEOzs7R0FHRztBQUNILFNBQVMsZ0JBQWdCLENBQ3ZCLEdBQVksRUFDWixPQUE0QjtJQUU1QixNQUFNLFdBQVcsR0FBRyxJQUFBLG1EQUFrQixFQUFDLEdBQUcsQ0FBQyxDQUFDO0lBRTVDLE9BQU87UUFDTCxHQUFHLENBQUMsV0FBVyxLQUFLLFNBQVMsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFLFdBQVcsRUFBRSxDQUFDO1FBQ3JELEdBQUcsQ0FBQyxPQUFPLEVBQUUsY0FBYyxLQUFLLFNBQVMsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFLGNBQWMsRUFBRSxPQUFPLENBQUMsY0FBYyxFQUFFLENBQUM7S0FDN0YsQ0FBQztBQUNKLENBQUM7QUFFRCxnR0FBZ0c7QUFDaEcsU0FBUyxTQUFTLENBQUMsS0FBZ0M7SUFDakQsT0FBTyxLQUFLLEtBQUssSUFBSSxJQUFJLEtBQUssS0FBSyxTQUFTLElBQUksS0FBSyxLQUFLLEVBQUUsQ0FBQztBQUMvRCxDQUFDO0FBRUQ7OztHQUdHO0FBQ0gsU0FBUyxnQkFBZ0IsQ0FBQyxXQUFnQztJQUN4RCxPQUFPLFNBQVMsQ0FBQyxXQUFXLEVBQUUsRUFBRSxDQUFDLElBQUksU0FBUyxDQUFDLFdBQVcsRUFBRSxVQUFVLEVBQUUsS0FBSyxDQUFDLENBQUM7QUFDakYsQ0FBQztBQVVEOzs7OztHQUtHO0FBQ0gsU0FBUywyQkFBMkIsQ0FBQyxFQUNuQyxHQUFHLEVBQ0gsTUFBTSxFQUNOLE9BQU8sRUFDUCxNQUFNLEVBQ04sS0FBSyxHQUN1QjtJQUM1QixNQUFNLFdBQVcsR0FBRyxFQUFFLEdBQUcsZ0JBQWdCLENBQUMsR0FBRyxFQUFFLE9BQU8sQ0FBQyxFQUFFLEtBQUssRUFBRSxhQUFhLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQztJQUV2RixJQUFJLElBQUEsNENBQXlCLEVBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQztRQUNyQyxNQUFNLENBQ0osTUFBTSxFQUNOLHFCQUFxQixNQUFNLGdFQUFnRTtZQUN6RixTQUFTLEVBQ1gsV0FBVyxDQUNaLENBQUM7UUFFRixPQUFPO0lBQ1QsQ0FBQztJQUVELE1BQU0sQ0FDSixPQUFPLEVBQ1AscUJBQXFCLE1BQU0seUNBQXlDLEVBQ3BFLFdBQVcsQ0FDWixDQUFDO0FBQ0osQ0FBQztBQUVELEtBQUssVUFBVSxrQkFBa0IsQ0FBQyxHQUFZO0lBQzVDLE1BQU0sV0FBVyxHQUFHLElBQUEsbURBQWtCLEVBQUMsR0FBRyxDQUFDLENBQUM7SUFFNUMsSUFBSSxXQUFXLEtBQUssU0FBUztRQUFFLE1BQU0sSUFBQSwrQkFBYyxFQUFDLG9CQUFvQixDQUFDLENBQUM7SUFFMUUsT0FBTztRQUNMLGlCQUFpQixFQUFFLE1BQU0sSUFBQSx5REFBd0IsRUFBQyxHQUFHLENBQUM7UUFDdEQsV0FBVyxFQUFFLE1BQU0sQ0FBQyxXQUFXLENBQUM7S0FDakMsQ0FBQztBQUNKLENBQUM7QUFFYyxLQUFLLFVBQVUsd0JBQXdCLENBQUMsRUFDckQsR0FBRyxFQUNILE9BQU8sRUFDUCxNQUFNLEVBQ04sT0FBTyxFQUNQLE1BQU0sR0FDMEI7SUFDaEMsTUFBTSxJQUFJLEdBQUcsY0FBYyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBRXBDLElBQUksV0FBNkIsQ0FBQztJQUVsQyxJQUFJLENBQUM7UUFDSCxXQUFXLEdBQUcsTUFBTSxrQkFBa0IsQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUM5QyxDQUFDO0lBQUMsT0FBTyxLQUFLLEVBQUUsQ0FBQztRQUNmLDJCQUEyQixDQUFDLEVBQUUsR0FBRyxFQUFFLE1BQU0sRUFBRSxPQUFPLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxDQUFDLENBQUM7UUFFckUsSUFBSSxJQUFJLEtBQUssT0FBTztZQUFFLE1BQU0sS0FBSyxDQUFDO1FBRWxDLE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztJQUVELE1BQU0sRUFBRSxpQkFBaUIsRUFBRSxXQUFXLEVBQUUsR0FBRyxXQUFXLENBQUM7SUFFdkQsSUFBSSxXQUFnQyxDQUFDO0lBRXJDLElBQUksQ0FBQztRQUNILFdBQVcsR0FBRyxNQUFNLE9BQU8sQ0FBQyxvQkFBb0IsQ0FBQztZQUMvQyxpQkFBaUI7WUFDakIsV0FBVztZQUNYLE1BQU07WUFDTixJQUFJO1lBQ0osY0FBYyxFQUFFLE9BQU8sRUFBRSxjQUFjO1lBQ3ZDLFFBQVEsRUFBRSxPQUFPLEVBQUUsUUFBUTtZQUMzQixTQUFTLEVBQUUsT0FBTyxFQUFFLFNBQVM7WUFDN0IsS0FBSyxFQUFFLE9BQU8sRUFBRSxLQUFLO1NBQ3RCLENBQUMsQ0FBQztJQUNMLENBQUM7SUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO1FBQ2YsTUFBTSxDQUFDLE9BQU8sRUFBRSxxQkFBcUIsTUFBTSx3QkFBd0IsRUFBRTtZQUNuRSxHQUFHLGdCQUFnQixDQUFDLEdBQUcsRUFBRSxPQUFPLENBQUM7WUFDakMsS0FBSyxFQUFFLGFBQWEsQ0FBQyxLQUFLLENBQUM7U0FDNUIsQ0FBQyxDQUFDO1FBRUgsSUFBSSxzQkFBc0IsQ0FBQyxLQUFLLENBQUM7WUFBRSxNQUFNLElBQUEscUNBQWtCLEdBQUUsQ0FBQztRQUM5RCxJQUFJLHdCQUF3QixDQUFDLEtBQUssQ0FBQztZQUFFLElBQUEsNkNBQXdCLEVBQUMsR0FBRyxDQUFDLENBQUM7UUFFbkUsSUFBSSxJQUFJLEtBQUssT0FBTyxFQUFFLENBQUM7WUFDckIsTUFBTSxxQkFBcUIsQ0FBQyxLQUFLLENBQUM7Z0JBQ2hDLENBQUMsQ0FBQyxJQUFBLG1DQUFnQixFQUFDLFNBQVMsRUFBRSx5QkFBeUIsQ0FBQztnQkFDeEQsQ0FBQyxDQUFDLElBQUEsbUNBQWdCLEVBQUMsNENBQXlCLENBQUMsQ0FBQztRQUNsRCxDQUFDO1FBRUQsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0lBRUQsSUFBSSxDQUFDLGdCQUFnQixDQUFDLFdBQVcsQ0FBQyxFQUFFLENBQUM7UUFDbkMsTUFBTSxDQUNKLE9BQU8sRUFDUCxxQkFBcUIsTUFBTSwrREFBK0Q7WUFDeEYsdURBQXVELEVBQ3pELGdCQUFnQixDQUFDLEdBQUcsRUFBRSxPQUFPLENBQUMsQ0FDL0IsQ0FBQztRQUVGLElBQUksSUFBSSxLQUFLLE9BQU87WUFBRSxNQUFNLElBQUEsbUNBQWdCLEVBQUMsNENBQXlCLENBQUMsQ0FBQztRQUV4RSxPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7SUFFRCxPQUFPLEVBQUUsV0FBVyxFQUFFLGlCQUFpQixFQUFFLENBQUM7QUFDNUMsQ0FBQztBQVVEOzs7Ozs7R0FNRztBQUNILFNBQVMsNEJBQTRCLENBQUMsS0FBYztJQUNsRCxJQUFJLENBQUMsQ0FBQyxLQUFLLFlBQVksOEJBQVMsQ0FBQztRQUFFLE9BQU8sSUFBSSxDQUFDO0lBRS9DLE9BQU8sS0FBSyxDQUFDLE1BQU0sSUFBSSxZQUFZLElBQUksNkJBQTZCLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsQ0FBQztBQUN6RixDQUFDO0FBRUQsS0FBSyxVQUFVLFlBQVksQ0FBQyxPQUErQixFQUFFLE9BQU8sR0FBRyxDQUFDO0lBQ3RFLE1BQU0sRUFBRSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsR0FBRyxPQUFPLENBQUM7SUFFckQsSUFBSSxDQUFDO1FBQ0gsTUFBTSxPQUFPLENBQUMsdUJBQXVCLENBQUM7WUFDcEMsaUJBQWlCLEVBQUUsT0FBTyxDQUFDLGlCQUFpQjtZQUM1QyxXQUFXLEVBQUUsT0FBTyxDQUFDLFdBQVc7WUFDaEMsTUFBTTtTQUNQLENBQUMsQ0FBQztJQUNMLENBQUM7SUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO1FBQ2YsSUFBSSw0QkFBNEIsQ0FBQyxLQUFLLENBQUMsSUFBSSxPQUFPLEdBQUcsbUJBQW1CLEVBQUUsQ0FBQztZQUN6RSxNQUFNLENBQUMsT0FBTyxFQUFFLG9EQUFvRCxFQUFFO2dCQUNwRSxPQUFPO2dCQUNQLFFBQVEsRUFBRSxtQkFBbUI7Z0JBQzdCLEtBQUssRUFBRSxhQUFhLENBQUMsS0FBSyxDQUFDO2FBQzVCLENBQUMsQ0FBQztZQUVILE1BQU0sSUFBSSxPQUFPLENBQU8sT0FBTyxDQUFDLEVBQUU7Z0JBQ2hDLDBGQUEwRjtnQkFDMUYsVUFBVSxDQUFDLE9BQU8sRUFBRSxxQkFBcUIsQ0FBQyxDQUFDLEtBQUssRUFBRSxDQUFDO1lBQ3JELENBQUMsQ0FBQyxDQUFDO1lBRUgsTUFBTSxZQUFZLENBQUMsT0FBTyxFQUFFLE9BQU8sR0FBRyxDQUFDLENBQUMsQ0FBQztZQUV6QyxPQUFPO1FBQ1QsQ0FBQztRQUVELE1BQU0sS0FBSyxDQUFDO0lBQ2QsQ0FBQztBQUNILENBQUM7QUFFRDs7O0dBR0c7QUFDSCxTQUFnQixlQUFlLENBQUMsT0FBK0I7SUFDN0QsTUFBTSxFQUFFLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLEdBQUcsT0FBTyxDQUFDO0lBRTVDLE9BQU87U0FDSixLQUFLLENBQ0osR0FBRyxFQUFFLENBQUMsWUFBWSxDQUFDLE9BQU8sQ0FBQyxFQUMzQixJQUFJLE1BQU0sb0NBQW9DLE9BQU8sQ0FBQyxPQUFPLENBQUMsV0FBVyxDQUFDLEVBQUUsRUFBRSxDQUMvRTtTQUNBLEtBQUssQ0FBQyxLQUFLLENBQUMsRUFBRTtRQUNiLE1BQU0sQ0FBQyxPQUFPLEVBQUUsdUNBQXVDLE1BQU0sR0FBRyxFQUFFO1lBQ2hFLGFBQWEsRUFBRSxPQUFPLENBQUMsT0FBTyxDQUFDLFdBQVcsQ0FBQyxFQUFFO1lBQzdDLEtBQUssRUFBRSxPQUFPLENBQUMsT0FBTyxDQUFDLFdBQVcsQ0FBQyxVQUFVLEVBQUUsS0FBSztZQUNwRCxLQUFLLEVBQUUsYUFBYSxDQUFDLEtBQUssQ0FBQztTQUM1QixDQUFDLENBQUM7SUFDTCxDQUFDLENBQUMsQ0FBQztBQUNQLENBQUMifQ==

package/dist/activity-log/activity-logs-service.d.ts

@@ -0,0 +1,18 @@
+import type { ActivityLogResponse, CreateActivityLogParams, UpdateActivityLogStatusParams } from '@forestadmin/forestadmin-client';
+export declare const APPLICATION_SOURCE_HEADER = "Forest-Application-Source";
+export declare const BFF_APPLICATION_SOURCE = "BFF";
+/**
+ * The slice of `ActivityLogsService` the BFF uses. Named so a fake can stand in for the two calls
+ * without carrying the rest of the Forest client.
+ */
+export interface ActivityLogsWriter {
+    createMcpActivityLog(params: CreateActivityLogParams): Promise<ActivityLogResponse>;
+    updateActivityLogStatus(params: UpdateActivityLogStatusParams): Promise<void>;
+}
+/**
+ * Its own instance rather than the client `oauth/forest-server-client.ts` already holds:
+ * `ForestAdminClientOptions` carries no `headers`, so that one cannot tell the server which channel
+ * wrote the log.
+ */
+export default function createBffActivityLogsService(forestServerUrl: string): ActivityLogsWriter;
+//# sourceMappingURL=activity-logs-service.d.ts.map

package/dist/activity-log/activity-logs-service.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BFF_APPLICATION_SOURCE = exports.APPLICATION_SOURCE_HEADER = void 0;
+exports.default = createBffActivityLogsService;
+const forestadmin_client_1 = require("@forestadmin/forestadmin-client");
+exports.APPLICATION_SOURCE_HEADER = 'Forest-Application-Source';
+exports.BFF_APPLICATION_SOURCE = 'BFF';
+/**
+ * Its own instance rather than the client `oauth/forest-server-client.ts` already holds:
+ * `ForestAdminClientOptions` carries no `headers`, so that one cannot tell the server which channel
+ * wrote the log.
+ */
+function createBffActivityLogsService(forestServerUrl) {
+    return new forestadmin_client_1.ActivityLogsService(new forestadmin_client_1.ForestHttpApi(), {
+        forestServerUrl,
+        headers: { [exports.APPLICATION_SOURCE_HEADER]: exports.BFF_APPLICATION_SOURCE },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aXZpdHktbG9ncy1zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FjdGl2aXR5LWxvZy9hY3Rpdml0eS1sb2dzLXNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBeUJBLCtDQUtDO0FBeEJELHdFQUFxRjtBQUV4RSxRQUFBLHlCQUF5QixHQUFHLDJCQUEyQixDQUFDO0FBQ3hELFFBQUEsc0JBQXNCLEdBQUcsS0FBSyxDQUFDO0FBVzVDOzs7O0dBSUc7QUFDSCxTQUF3Qiw0QkFBNEIsQ0FBQyxlQUF1QjtJQUMxRSxPQUFPLElBQUksd0NBQW1CLENBQUMsSUFBSSxrQ0FBYSxFQUFFLEVBQUU7UUFDbEQsZUFBZTtRQUNmLE9BQU8sRUFBRSxFQUFFLENBQUMsaUNBQXlCLENBQUMsRUFBRSw4QkFBc0IsRUFBRTtLQUNqRSxDQUFDLENBQUM7QUFDTCxDQUFDIn0=

package/dist/activity-log/with-activity-log.d.ts

@@ -0,0 +1,25 @@
+import type ActivityLogDrainer from './activity-log-drainer';
+import type { ActivityLogContext, BffActivityLogAction } from './activity-logs-creator';
+import type { ActivityLogsWriter } from './activity-logs-service';
+import type { Logger } from '../ports/logger-port';
+import type { Context } from 'koa';
+export interface WithActivityLogOptions<T> {
+    ctx: Context;
+    service: ActivityLogsWriter;
+    drainer: ActivityLogDrainer;
+    action: BffActivityLogAction;
+    context?: ActivityLogContext;
+    logger: Logger;
+    operation: () => Promise<T>;
+    /**
+     * Errors the log records as `completed` rather than `failed` — the operation reached a business
+     * outcome the BFF answers with an error status.
+     */
+    isCompletedDespite?: (error: unknown) => boolean;
+}
+/**
+ * Runs an operation under an activity log: the pending log is awaited before the operation starts,
+ * so nothing runs unaudited, and the status transition is fired without `await` afterwards.
+ */
+export default function withActivityLog<T>(options: WithActivityLogOptions<T>): Promise<T>;
+//# sourceMappingURL=with-activity-log.d.ts.map