@forestadmin/workflow-executor 1.33.1 → 1.34.0

package/dist/adapters/server-types.d.ts

@@ -5,6 +5,7 @@
  * Contains both step-level types (workflow step variants) and the run envelope
  * (HydratedWorkflowRun + user profile + step history).
  */
+import { z } from 'zod';
 export interface ServerWorkflowTransition {
     stepId: string;
     buttonText: string | null;
@@ -172,7 +173,8 @@ export type ServerWorkflowRunState = 'started' | 'pending' | 'loading' | 'aborte
 export declare enum ServerWorkflowTriggerType {
     manual = "manual",
     webhook = "webhook",
-    mcp = "mcp"
+    mcp = "mcp",
+    dataChange = "dataChange"
 }
 export interface ServerHydratedWorkflowRun {
     id: number;
@@ -222,5 +224,121 @@ export interface ServerUpdateStepRequest {
     stepUpdate: ServerStepUpdate;
     executionStatus: ServerExecutionStatus;
 }
+export interface ServerReleaseRunRequest {
+    runId: number;
+    lockedAt: string;
+}
+export type ServerPlainConditionTree = {
+    field: string;
+    operator: string;
+    value?: unknown;
+} | {
+    aggregator: string;
+    conditions: ServerPlainConditionTree[];
+};
+export declare const ServerAutomatedSegmentDescriptorSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"smart">;
+    name: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"sql">;
+    query: z.ZodString;
+    connectionName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"filter">;
+    conditionTree: z.ZodType<ServerPlainConditionTree, unknown, z.core.$ZodTypeInternals<ServerPlainConditionTree, unknown>>;
+}, z.core.$strip>], "kind">;
+export type ServerAutomatedSegmentDescriptor = z.infer<typeof ServerAutomatedSegmentDescriptorSchema>;
+export declare const ServerAutomatedInboxServiceAccountProfileSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    email: z.ZodString;
+    firstName: z.ZodNullable<z.ZodString>;
+    lastName: z.ZodNullable<z.ZodString>;
+    team: z.ZodNullable<z.ZodString>;
+    renderingId: z.ZodNumber;
+    role: z.ZodNullable<z.ZodString>;
+    permissionLevel: z.ZodNullable<z.ZodString>;
+    tags: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>;
+export type ServerAutomatedInboxServiceAccountProfile = z.infer<typeof ServerAutomatedInboxServiceAccountProfileSchema>;
+export declare const ServerAutomatedInboxConfigSchema: z.ZodObject<{
+    inboxId: z.ZodString;
+    renderingId: z.ZodOptional<z.ZodNumber>;
+    workflowId: z.ZodOptional<z.ZodString>;
+    collectionName: z.ZodString;
+    primaryKeys: z.ZodArray<z.ZodString>;
+    maxConcurrentRuns: z.ZodNumber;
+    timezone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    liana: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    lianaVersion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    segment: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"smart">;
+        name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"sql">;
+        query: z.ZodString;
+        connectionName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"filter">;
+        conditionTree: z.ZodType<ServerPlainConditionTree, unknown, z.core.$ZodTypeInternals<ServerPlainConditionTree, unknown>>;
+    }, z.core.$strip>], "kind">;
+    sort: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        ascending: z.ZodBoolean;
+    }, z.core.$strip>>>>;
+    serviceAccountProfile: z.ZodObject<{
+        id: z.ZodNumber;
+        email: z.ZodString;
+        firstName: z.ZodNullable<z.ZodString>;
+        lastName: z.ZodNullable<z.ZodString>;
+        team: z.ZodNullable<z.ZodString>;
+        renderingId: z.ZodNumber;
+        role: z.ZodNullable<z.ZodString>;
+        permissionLevel: z.ZodNullable<z.ZodString>;
+        tags: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ServerAutomatedInboxConfig = z.infer<typeof ServerAutomatedInboxConfigSchema>;
+export declare const ServerAutomatedInboxesResponseSchema: z.ZodObject<{
+    inboxes: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const ServerAutomationLeaseResponseSchema: z.ZodObject<{
+    held: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const ServerAutomatedInboxAssignmentSchema: z.ZodObject<{
+    recordId: z.ZodString;
+    state: z.ZodString;
+    workflowRunId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    runState: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type ServerAutomatedInboxAssignment = z.infer<typeof ServerAutomatedInboxAssignmentSchema>;
+export declare const ServerAutomatedInboxAssignmentsResponseSchema: z.ZodObject<{
+    assignments: z.ZodArray<z.ZodObject<{
+        recordId: z.ZodString;
+        state: z.ZodString;
+        workflowRunId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        runState: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const SERVER_AUTOMATED_INBOX_READ_FAILURE_REASONS: readonly ["agent-forbidden", "agent-unreachable", "segment-read-failed"];
+export type ServerAutomatedInboxReadFailureReason = (typeof SERVER_AUTOMATED_INBOX_READ_FAILURE_REASONS)[number];
+export interface ServerAutomatedInboxReadFailure {
+    reason: ServerAutomatedInboxReadFailureReason;
+    httpStatus?: number;
+}
+export interface ServerAutomatedInboxSyncRequest {
+    closed: {
+        recordId: string;
+        stillInSegment: boolean;
+    }[];
+    candidates: string[];
+    readFailure?: ServerAutomatedInboxReadFailure;
+}
+export declare const ServerAutomatedInboxSyncResponseSchema: z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        recordId: z.ZodString;
+        outcome: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ServerAutomatedInboxSyncResponse = z.infer<typeof ServerAutomatedInboxSyncResponseSchema>;
 export {};
 //# sourceMappingURL=server-types.d.ts.map

package/dist/adapters/server-types.js

@@ -7,7 +7,8 @@
  * (HydratedWorkflowRun + user profile + step history).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServerWorkflowTriggerType = exports.ServerStepExecutionTypeEnum = exports.ServerTaskTypeEnum = exports.ServerStepTypeEnum = void 0;
+exports.ServerAutomatedInboxSyncResponseSchema = exports.SERVER_AUTOMATED_INBOX_READ_FAILURE_REASONS = exports.ServerAutomatedInboxAssignmentsResponseSchema = exports.ServerAutomatedInboxAssignmentSchema = exports.ServerAutomationLeaseResponseSchema = exports.ServerAutomatedInboxesResponseSchema = exports.ServerAutomatedInboxConfigSchema = exports.ServerAutomatedInboxServiceAccountProfileSchema = exports.ServerAutomatedSegmentDescriptorSchema = exports.ServerWorkflowTriggerType = exports.ServerStepExecutionTypeEnum = exports.ServerTaskTypeEnum = exports.ServerStepTypeEnum = void 0;
+const zod_1 = require("zod");
 var ServerStepTypeEnum;
 (function (ServerStepTypeEnum) {
     ServerStepTypeEnum["Task"] = "task";
@@ -37,5 +38,106 @@ var ServerWorkflowTriggerType;
     ServerWorkflowTriggerType["manual"] = "manual";
     ServerWorkflowTriggerType["webhook"] = "webhook";
     ServerWorkflowTriggerType["mcp"] = "mcp";
+    ServerWorkflowTriggerType["dataChange"] = "dataChange";
 })(ServerWorkflowTriggerType || (exports.ServerWorkflowTriggerType = ServerWorkflowTriggerType = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmVyLXR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FkYXB0ZXJzL3NlcnZlci10eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7OztHQU1HOzs7QUFTSCxJQUFZLGtCQU9YO0FBUEQsV0FBWSxrQkFBa0I7SUFDNUIsbUNBQWEsQ0FBQTtJQUNiLDZDQUF1QixDQUFBO0lBQ3ZCLGlDQUFXLENBQUE7SUFDWCwrQ0FBeUIsQ0FBQTtJQUN6Qiw2REFBdUMsQ0FBQTtJQUN2Qyw2REFBdUMsQ0FBQTtBQUN6QyxDQUFDLEVBUFcsa0JBQWtCLGtDQUFsQixrQkFBa0IsUUFPN0I7QUFFRCxJQUFZLGtCQU9YO0FBUEQsV0FBWSxrQkFBa0I7SUFDNUIsNkNBQXVCLENBQUE7SUFDdkIsc0RBQWdDLENBQUE7SUFDaEMsMENBQW9CLENBQUE7SUFDcEIsZ0RBQTBCLENBQUE7SUFDMUIsK0RBQXlDLENBQUE7SUFDekMsOENBQXdCLENBQUE7QUFDMUIsQ0FBQyxFQVBXLGtCQUFrQixrQ0FBbEIsa0JBQWtCLFFBTzdCO0FBRUQsSUFBWSwyQkFJWDtBQUpELFdBQVksMkJBQTJCO0lBQ3JDLGdEQUFpQixDQUFBO0lBQ2pCLHdGQUF5RCxDQUFBO0lBQ3pELGlFQUFrQyxDQUFBO0FBQ3BDLENBQUMsRUFKVywyQkFBMkIsMkNBQTNCLDJCQUEyQixRQUl0QztBQThLRCxJQUFZLHlCQUlYO0FBSkQsV0FBWSx5QkFBeUI7SUFDbkMsOENBQWlCLENBQUE7SUFDakIsZ0RBQW1CLENBQUE7SUFDbkIsd0NBQVcsQ0FBQTtBQUNiLENBQUMsRUFKVyx5QkFBeUIseUNBQXpCLHlCQUF5QixRQUlwQyJ9
+// Branch first, deliberately: a node carrying both `conditions` and `field` is ambiguous, and the
+// leaf schema would match it and strip the conditions, leaving a filter that reads a different
+// segment than the one configured. agent-client's own `toWireFilter` resolves it the same way.
+//
+// Both discriminators are required and a branch may not be empty. The agent reads `And` over
+// nothing as matching every record, so a tree this schema let through half-formed would widen the
+// segment to the whole collection rather than fail — the one failure mode worth a rejected inbox.
+const ServerPlainConditionTreeSchema = zod_1.z.lazy(() => zod_1.z.union([
+    zod_1.z.object({
+        aggregator: zod_1.z.string().min(1),
+        conditions: zod_1.z.array(ServerPlainConditionTreeSchema).min(1),
+    }),
+    // `value` is optional, not merely `unknown`: zod requires an `unknown` key to be present, and
+    // the operators the agent evaluates on its own — `present`, `blank`, `today`, every
+    // `previous_*` — are emitted as `{ field, operator }` with no value at all.
+    zod_1.z.object({
+        field: zod_1.z.string().min(1),
+        operator: zod_1.z.string().min(1),
+        value: zod_1.z.unknown().optional(),
+    }),
+]));
+exports.ServerAutomatedSegmentDescriptorSchema = zod_1.z.discriminatedUnion('kind', [
+    zod_1.z.object({ kind: zod_1.z.literal('smart'), name: zod_1.z.string().min(1) }),
+    zod_1.z.object({
+        kind: zod_1.z.literal('sql'),
+        query: zod_1.z.string().min(1),
+        // Null on the lianas that run a bare `segmentQuery` themselves (forest-rails,
+        // forest-express-sequelize). The server never emits a `sql` descriptor without one for a v2
+        // agent — it degrades the inbox instead.
+        connectionName: zod_1.z.string().nullish(),
+    }),
+    zod_1.z.object({ kind: zod_1.z.literal('filter'), conditionTree: ServerPlainConditionTreeSchema }),
+]);
+// `ServerUserProfile` without `serverToken`: there is no run yet, and the poller only reaches the
+// SaaS with the environment secret. The executor mints its agent JWT from this profile, through the
+// same `toStepUser` the run envelope goes through — which is what keeps the two shapes tied.
+exports.ServerAutomatedInboxServiceAccountProfileSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    email: zod_1.z.string(),
+    firstName: zod_1.z.string().nullable(),
+    lastName: zod_1.z.string().nullable(),
+    team: zod_1.z.string().nullable(),
+    renderingId: zod_1.z.number().int().nonnegative(),
+    role: zod_1.z.string().nullable(),
+    permissionLevel: zod_1.z.string().nullable(),
+    tags: zod_1.z.record(zod_1.z.string(), zod_1.z.string()),
+});
+// Only what the poller reads is required. A field it merely logs must never be the reason an inbox
+// is dropped from the sweep, and `.nullable()` alone would still reject an omitted key.
+exports.ServerAutomatedInboxConfigSchema = zod_1.z.object({
+    inboxId: zod_1.z.string().min(1),
+    renderingId: zod_1.z.number().int().nonnegative().optional(),
+    workflowId: zod_1.z.string().min(1).optional(),
+    collectionName: zod_1.z.string().min(1),
+    primaryKeys: zod_1.z.array(zod_1.z.string().min(1)).min(1),
+    maxConcurrentRuns: zod_1.z.number().int().positive(),
+    timezone: zod_1.z.string().nullish(),
+    // Which agent answers the segment read. Absent on an orchestrator that predates the exclusion
+    // filter, which reads as unknown: the poller then pads its page, as it always did.
+    liana: zod_1.z.string().nullish(),
+    // Absent on an orchestrator that predates it, which reads as a version too old to sort on several
+    // fields.
+    lianaVersion: zod_1.z.string().nullish(),
+    segment: exports.ServerAutomatedSegmentDescriptorSchema,
+    // A sort the executor cannot read costs the inbox its order, never the inbox itself.
+    sort: zod_1.z
+        .array(zod_1.z.object({ field: zod_1.z.string().min(1), ascending: zod_1.z.boolean() }))
+        .min(1)
+        .optional()
+        .catch(undefined),
+    serviceAccountProfile: exports.ServerAutomatedInboxServiceAccountProfileSchema,
+});
+exports.ServerAutomatedInboxesResponseSchema = zod_1.z.object({
+    inboxes: zod_1.z.array(zod_1.z.unknown()),
+});
+exports.ServerAutomationLeaseResponseSchema = zod_1.z.object({ held: zod_1.z.boolean() });
+// States are read as plain strings, not enums: the poller only ever tests set membership, and one
+// assignment in a state a newer orchestrator introduced must not take the whole inbox down.
+exports.ServerAutomatedInboxAssignmentSchema = zod_1.z.object({
+    recordId: zod_1.z.string(),
+    state: zod_1.z.string(),
+    workflowRunId: zod_1.z.number().nullish(),
+    runState: zod_1.z.string().nullish(),
+});
+exports.ServerAutomatedInboxAssignmentsResponseSchema = zod_1.z.object({
+    assignments: zod_1.z.array(exports.ServerAutomatedInboxAssignmentSchema),
+});
+exports.SERVER_AUTOMATED_INBOX_READ_FAILURE_REASONS = [
+    'agent-forbidden',
+    'agent-unreachable',
+    'segment-read-failed',
+];
+exports.ServerAutomatedInboxSyncResponseSchema = zod_1.z.object({
+    results: zod_1.z.array(zod_1.z.object({
+        recordId: zod_1.z.string(),
+        // Unknown outcomes are kept as-is: the poller only counts them for logs, and refusing the
+        // whole response would stop a sync the server already applied.
+        outcome: zod_1.z.string(),
+    })),
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/adapters/step-user.d.ts

@@ -0,0 +1,23 @@
+import type { StepUser } from '../types/execution-context';
+/**
+ * What a run envelope's `userProfile` and an automated inbox's service-account profile have in
+ * common. The optional strings are what the server actually sends as null.
+ */
+export interface StepUserProfile {
+    id: number;
+    email: string;
+    firstName?: string | null;
+    lastName?: string | null;
+    team?: string | null;
+    renderingId: number;
+    role?: string | null;
+    permissionLevel?: string | null;
+    tags: Record<string, string>;
+}
+/**
+ * Shared so a run-driven step and an automation poll reach the agent as the exact same caller: the
+ * JWT they mint has to carry identical claims, or the same account would be two callers.
+ */
+export declare function toStepUser(profile: StepUserProfile): StepUser;
+export declare function mintStepToken(user: StepUser, authSecret: string): string;
+//# sourceMappingURL=step-user.d.ts.map

package/dist/adapters/step-user.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toStepUser = toStepUser;
+exports.mintStepToken = mintStepToken;
+const agent_client_1 = require("@forestadmin/agent-client");
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const AGENT_TOKEN_TTL = '5m';
+/**
+ * Shared so a run-driven step and an automation poll reach the agent as the exact same caller: the
+ * JWT they mint has to carry identical claims, or the same account would be two callers.
+ */
+function toStepUser(profile) {
+    return {
+        id: profile.id,
+        email: profile.email,
+        firstName: profile.firstName ?? '',
+        lastName: profile.lastName ?? '',
+        team: profile.team ?? '',
+        renderingId: profile.renderingId,
+        role: profile.role ?? '',
+        permissionLevel: profile.permissionLevel ?? '',
+        tags: profile.tags,
+    };
+}
+function mintStepToken(user, authSecret) {
+    return jsonwebtoken_1.default.sign({ ...(0, agent_client_1.toAgentTokenClaims)(user), scope: 'step-execution' }, authSecret, {
+        expiresIn: AGENT_TOKEN_TTL,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RlcC11c2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FkYXB0ZXJzL3N0ZXAtdXNlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQTJCQSxnQ0FZQztBQUVELHNDQUlDO0FBM0NELDREQUErRDtBQUMvRCxnRUFBd0M7QUFFeEMsTUFBTSxlQUFlLEdBQUcsSUFBSSxDQUFDO0FBa0I3Qjs7O0dBR0c7QUFDSCxTQUFnQixVQUFVLENBQUMsT0FBd0I7SUFDakQsT0FBTztRQUNMLEVBQUUsRUFBRSxPQUFPLENBQUMsRUFBRTtRQUNkLEtBQUssRUFBRSxPQUFPLENBQUMsS0FBSztRQUNwQixTQUFTLEVBQUUsT0FBTyxDQUFDLFNBQVMsSUFBSSxFQUFFO1FBQ2xDLFFBQVEsRUFBRSxPQUFPLENBQUMsUUFBUSxJQUFJLEVBQUU7UUFDaEMsSUFBSSxFQUFFLE9BQU8sQ0FBQyxJQUFJLElBQUksRUFBRTtRQUN4QixXQUFXLEVBQUUsT0FBTyxDQUFDLFdBQVc7UUFDaEMsSUFBSSxFQUFFLE9BQU8sQ0FBQyxJQUFJLElBQUksRUFBRTtRQUN4QixlQUFlLEVBQUUsT0FBTyxDQUFDLGVBQWUsSUFBSSxFQUFFO1FBQzlDLElBQUksRUFBRSxPQUFPLENBQUMsSUFBSTtLQUNuQixDQUFDO0FBQ0osQ0FBQztBQUVELFNBQWdCLGFBQWEsQ0FBQyxJQUFjLEVBQUUsVUFBa0I7SUFDOUQsT0FBTyxzQkFBWSxDQUFDLElBQUksQ0FBQyxFQUFFLEdBQUcsSUFBQSxpQ0FBa0IsRUFBQyxJQUFJLENBQUMsRUFBRSxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsRUFBRSxVQUFVLEVBQUU7UUFDN0YsU0FBUyxFQUFFLGVBQWU7S0FDM0IsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyJ9

package/dist/automation/automation-poller.d.ts

@@ -0,0 +1,45 @@
+import type { AutomationPort } from '../ports/automation-port';
+import type { Logger } from '../ports/logger-port';
+import type { SegmentReaderPort } from '../ports/segment-reader-port';
+export type AutomationPollerState = 'idle' | 'running' | 'draining' | 'stopped';
+export interface AutomationPollerConfig {
+    automationPort: AutomationPort;
+    segmentReaderPort: SegmentReaderPort;
+    pollingIntervalS: number;
+    /**
+     * Identifies this process to the orchestrator's single-poller election. Stable for the process's
+     * lifetime, distinct across instances.
+     */
+    instanceId: string;
+    logger?: Logger;
+    stopTimeoutS?: number;
+}
+/**
+ * Drives the automated inboxes of one environment: asks the orchestrator which ones to poll, reads
+ * their segment on the client's agent, and reports back. It never decides what runs — the
+ * orchestrator owns the concurrency cap, the active-run check and the run start.
+ *
+ * Kept apart from `Runner`: they share nothing but a polling shape, and a failure on one side must
+ * not stop the other.
+ */
+export default class AutomationPoller {
+    private readonly config;
+    private readonly logger;
+    private readonly inFlightInboxes;
+    private tickTimer;
+    private currentTick;
+    private currentCycle;
+    private readonly lease;
+    private readonly inboxPoll;
+    private sweepCutShort;
+    private nextSweepAt;
+    private _state;
+    constructor(config: AutomationPollerConfig);
+    get state(): AutomationPollerState;
+    start(): void;
+    stop(): Promise<void>;
+    private scheduleTick;
+    private tick;
+    private runPollCycle;
+}
+//# sourceMappingURL=automation-poller.d.ts.map

package/dist/automation/automation-poller.js

@@ -0,0 +1,201 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const inbox_poll_1 = __importDefault(require("./inbox-poll"));
+const lease_keeper_1 = __importDefault(require("./lease-keeper"));
+const console_logger_1 = __importDefault(require("../adapters/console-logger"));
+const defaults_1 = require("../defaults");
+const errors_1 = require("../errors");
+const in_flight_run_registry_1 = __importDefault(require("../in-flight-run-registry"));
+// Every inbox reads the customer's agent several times. Sweeping them all at once piles those reads
+// onto the customer's database, and agent-client's ten-second timeout turns the pile-up into inboxes
+// whose reads time out.
+const MAX_CONCURRENT_INBOX_POLLS = 5;
+// The orchestrator's poller lease lives three of these, so a dead holder is replaced within a
+// minute. Kept apart from the sweep interval: a sweep can last longer than the lease.
+const LEASE_HEARTBEAT_INTERVAL_S = 15;
+/**
+ * Drives the automated inboxes of one environment: asks the orchestrator which ones to poll, reads
+ * their segment on the client's agent, and reports back. It never decides what runs — the
+ * orchestrator owns the concurrency cap, the active-run check and the run start.
+ *
+ * Kept apart from `Runner`: they share nothing but a polling shape, and a failure on one side must
+ * not stop the other.
+ */
+class AutomationPoller {
+    constructor(config) {
+        this.inFlightInboxes = new in_flight_run_registry_1.default();
+        this.tickTimer = null;
+        this.currentTick = null;
+        // The cycle itself, not just the inbox polls it spawns: a cycle still waiting on the config route
+        // has registered nothing, and draining only the registry would let it read and write after the
+        // host was told the poller had stopped.
+        this.currentCycle = null;
+        this.lease = new lease_keeper_1.default();
+        this.sweepCutShort = false;
+        this.nextSweepAt = 0;
+        this._state = 'idle';
+        this.config = config;
+        this.logger = config.logger ?? (0, console_logger_1.default)();
+        this.inboxPoll = new inbox_poll_1.default({
+            automationPort: config.automationPort,
+            segmentReaderPort: config.segmentReaderPort,
+            logger: this.logger,
+        });
+    }
+    get state() {
+        return this._state;
+    }
+    start() {
+        if (this._state === 'stopped' || this._state === 'draining') {
+            throw new Error('AutomationPoller has been stopped and cannot be restarted');
+        }
+        if (this._state === 'running')
+            return;
+        // `AUTOMATION_POLL_INTERVAL_S=0` turns the sweep off. The poller stays constructed and `stop()`
+        // still answers, so nothing downstream has to know an executor is running without it.
+        if (this.config.pollingIntervalS === 0) {
+            this.logger('Info', 'Automation poller disabled by configuration', {
+                instanceId: this.config.instanceId,
+            });
+            return;
+        }
+        this._state = 'running';
+        this.logger('Info', 'Automation poller started', {
+            instanceId: this.config.instanceId,
+            pollingIntervalS: this.config.pollingIntervalS,
+        });
+        this.scheduleTick(0);
+    }
+    async stop() {
+        if (this._state !== 'running')
+            return;
+        this._state = 'draining';
+        if (this.tickTimer !== null) {
+            clearTimeout(this.tickTimer);
+            this.tickTimer = null;
+        }
+        try {
+            const timeoutS = this.config.stopTimeoutS ?? defaults_1.DEFAULT_STOP_TIMEOUT_S;
+            let drainTimer;
+            const outcome = await Promise.race([
+                Promise.allSettled([
+                    this.currentTick,
+                    this.currentCycle,
+                    this.inFlightInboxes.drain(),
+                ]).then(() => {
+                    if (drainTimer)
+                        clearTimeout(drainTimer);
+                    return 'drained';
+                }),
+                new Promise(resolve => {
+                    drainTimer = setTimeout(() => resolve('timeout'), timeoutS * 1000);
+                    // The bound on a shutdown wait must not itself become a reason to stay up.
+                    drainTimer.unref?.();
+                }),
+            ]);
+            if (outcome === 'timeout') {
+                this.logger('Error', 'Automation poller drain timeout', {
+                    remainingInboxes: this.inFlightInboxes.keys(),
+                    timeoutS,
+                });
+            }
+        }
+        finally {
+            this._state = 'stopped';
+            this.logger('Info', 'Automation poller stopped', {});
+        }
+    }
+    scheduleTick(delayMs) {
+        if (this._state !== 'running')
+            return;
+        this.tickTimer = setTimeout(() => {
+            this.currentTick = this.tick();
+        }, delayMs);
+        // A background heartbeat must not be the reason a process stays alive: the host owns that.
+        this.tickTimer.unref?.();
+    }
+    async tick() {
+        try {
+            const held = await this.config.automationPort.holdLease(this.config.instanceId);
+            if (this._state !== 'running')
+                return;
+            if (this.lease.recordBeat(held, Date.now()).roleChanged) {
+                this.logger('Info', held
+                    ? 'Holding the automation poller lease, this instance sweeps the automated inboxes'
+                    : 'Standing by, another instance sweeps the automated inboxes', { instanceId: this.config.instanceId });
+            }
+            if (!held) {
+                this.nextSweepAt = 0;
+                return;
+            }
+            if (this.currentCycle === null && Date.now() >= this.nextSweepAt) {
+                this.sweepCutShort = false;
+                // Not awaited: the heartbeat has to keep the lease through a sweep that outlasts it.
+                this.currentCycle = this.runPollCycle().finally(() => {
+                    this.currentCycle = null;
+                    // The inboxes a lost lease left undispatched are owed as soon as the lease is back.
+                    this.nextSweepAt = this.sweepCutShort
+                        ? 0
+                        : Date.now() + this.config.pollingIntervalS * 1000;
+                });
+            }
+        }
+        catch (error) {
+            this.logger('Error', 'Automation poller lease heartbeat failed', {
+                instanceId: this.config.instanceId,
+                error: (0, errors_1.extractErrorMessage)(error),
+            });
+            if (this.lease.recordFailedBeat(Date.now()).trustLost) {
+                this.logger('Warn', 'No heartbeat landed for too long, standing by until one does', {
+                    instanceId: this.config.instanceId,
+                });
+                this.nextSweepAt = 0;
+            }
+        }
+        finally {
+            this.scheduleTick(LEASE_HEARTBEAT_INTERVAL_S * 1000);
+        }
+    }
+    async runPollCycle() {
+        try {
+            const inboxes = await this.config.automationPort.listAutomatedInboxes(this.config.instanceId);
+            // `stop()` may have run while that call was out. Dispatching now would read the customer's
+            // agent and start runs during a shutdown that is only waiting on this cycle to end.
+            if (this._state !== 'running')
+                return;
+            if (inboxes.length === 0) {
+                this.logger('Debug', 'No automated inbox to poll', { instanceId: this.config.instanceId });
+                return;
+            }
+            this.logger('Debug', 'Automation poll cycle started', { fetched: inboxes.length });
+            // Awaited, so no other cycle starts before this one is done: a slow segment read delays the
+            // sweep instead of stacking a second one on the customer's database. The registry is what
+            // `stop()` drains.
+            const queue = [...inboxes];
+            const sweepQueue = async () => {
+                let inbox = queue.shift();
+                // A lost lease means another instance may already be sweeping these inboxes.
+                while (inbox && this._state === 'running' && this.lease.isTrusted(Date.now())) {
+                    // eslint-disable-next-line no-await-in-loop
+                    await this.inFlightInboxes.track(inbox.inboxId, this.inboxPoll.poll(inbox));
+                    inbox = queue.shift();
+                }
+                if (inbox && this._state === 'running')
+                    this.sweepCutShort = true;
+            };
+            await Promise.all(Array.from({ length: Math.min(MAX_CONCURRENT_INBOX_POLLS, queue.length) }, sweepQueue));
+        }
+        catch (error) {
+            this.logger('Error', 'Automation poll cycle failed', {
+                instanceId: this.config.instanceId,
+                error: (0, errors_1.extractErrorMessage)(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+        }
+    }
+}
+exports.default = AutomationPoller;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"automation-poller.js","sourceRoot":"","sources":["../../src/automation/automation-poller.ts"],"names":[],"mappings":"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"}

package/dist/automation/inbox-poll.d.ts

@@ -0,0 +1,47 @@
+import type { AutomationPort } from '../ports/automation-port';
+import type { Logger } from '../ports/logger-port';
+import type { SegmentReaderPort } from '../ports/segment-reader-port';
+import type { AutomatedInbox } from '../types/automation';
+/**
+ * One sweep of one automated inbox: reconciles the records whose run is over, reads new candidates,
+ * and reports both to the orchestrator in a single sync.
+ */
+export default class InboxPoll {
+    private readonly automationPort;
+    private readonly segmentReaderPort;
+    private readonly logger;
+    constructor(params: {
+        automationPort: AutomationPort;
+        segmentReaderPort: SegmentReaderPort;
+        logger: Logger;
+    });
+    poll(inbox: AutomatedInbox): Promise<void>;
+    /**
+     * A record whose run is over is only treated once it has left the segment. Reading the assignment
+     * state alone is not enough: a record reported still in the segment while its run is going would
+     * be judged untreated before the run had a chance to take it out.
+     */
+    private reconcileClosed;
+    /**
+     * Runs one of the two segment reads. A failure yields an empty list rather than ending the poll,
+     * so the other read and the sync still happen — but it is reported as a failure, because "read
+     * nothing" and "could not read" must not look alike to the caller.
+     */
+    private tryRead;
+    /**
+     * Asks the agent for records the orchestrator has no assignment for. Excluding them in the query
+     * is what keeps the page at the run cap: a record already treated but still in the segment stays
+     * there for good, and left in the page it would take a slot on every poll from then on.
+     */
+    private readCandidates;
+    private readPaddedCandidates;
+    /**
+     * A sort field renamed or out of the service account's reach must not stop the inbox from
+     * dispatching. Used on the not_in read and the first padded page only: a refused sort is refused
+     * on the first page already. The order is dropped for the rest of the candidate read only once the
+     * read without it succeeds, since a read failing both ways says nothing against the sort.
+     */
+    private readWithInboxSort;
+    private paddedPageReason;
+}
+//# sourceMappingURL=inbox-poll.d.ts.map