sailfork / t3code-github / infra/ relay/ src/ agentActivity/ AgentActivityPublisher.ts

import {
  makeAggregateState,
  TERMINAL_AGENT_ACTIVITY_DISPLAY_TTL_MS,
} from "./agentActivityAggregate.ts";
import type {
  RelayAgentActivityState,
  RelayDeliveryResult,
  RelayPublishResponse,
} from "@t3tools/contracts/relay";
import * as Arr from "effect/Array";
import * as Context from "effect/Context";
import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";

import { isTerminalPhase } from "./agentActivityPayloads.ts";

export { isExpiredAgentActivityState } from "./agentActivityPayloads.ts";
import * as AgentActivityRows from "./AgentActivityRows.ts";
import * as EnvironmentLinks from "../environments/EnvironmentLinks.ts";
import * as LiveActivities from "./LiveActivities.ts";
import * as ApnsDeliveries from "./ApnsDeliveries.ts";
import * as FcmDeliveries from "./FcmDeliveries.ts";

export type AgentActivityPublishError =
  | FcmDeliveries.FcmDeliveryError
  | AgentActivityRows.AgentActivityRowUpsertPersistenceError
  | AgentActivityRows.AgentActivityRowDeletePersistenceError
  | AgentActivityRows.AgentActivityRowListPersistenceError
  | EnvironmentLinks.EnvironmentLinkUserListPersistenceError
  | LiveActivities.LiveActivityTargetListPersistenceError
  | ApnsDeliveries.ApnsDeliveryError;

export class AgentActivityPublisher extends Context.Service<
  AgentActivityPublisher,
  {
    readonly publish: (input: {
      readonly environmentId: string;
      readonly environmentPublicKey: string;
      readonly threadId: string;
      readonly state: RelayAgentActivityState | null;
    }) => Effect.Effect<RelayPublishResponse, AgentActivityPublishError>;
    readonly replayForLiveActivityRegistration: (input: {
      readonly userId: string;
      readonly deviceId: string;
    }) => Effect.Effect<RelayDeliveryResult | null, AgentActivityPublishError>;
    readonly endIdleLiveActivities: Effect.Effect<
      void,
      LiveActivities.LiveActivityIdleTargetListPersistenceError
    >;
  }
>()("t3code-relay/agentActivity/AgentActivityPublisher") {}

const make = Effect.gen(function* () {
  const rows = yield* AgentActivityRows.AgentActivityRows;
  const links = yield* EnvironmentLinks.EnvironmentLinks;
  const liveActivities = yield* LiveActivities.LiveActivities;
  const apnsDeliveries = yield* ApnsDeliveries.ApnsDeliveries;
  const fcmDeliveries = yield* FcmDeliveries.FcmDeliveries;

  const publishForDeliveryUser = Effect.fnUntraced(function* (input: {
    readonly deliveryUser: EnvironmentLinks.AgentAwarenessDeliveryUserRecord;
    readonly state: RelayAgentActivityState | null;
    readonly nowMs: number;
  }) {
    const activeStates = input.deliveryUser.liveActivitiesEnabled
      ? yield* rows.listForUser({ userId: input.deliveryUser.userId })
      : [];
    const liveActivityAggregate = input.deliveryUser.liveActivitiesEnabled
      ? makeAggregateState({
          activeStates,
          terminalState: input.state && isTerminalPhase(input.state) ? input.state : null,
          nowMs: input.nowMs,
        })
      : null;
    const notificationOnlyAggregate =
      input.deliveryUser.notificationsEnabled &&
      !input.deliveryUser.liveActivitiesEnabled &&
      input.state !== null
        ? makeAggregateState({
            activeStates: isTerminalPhase(input.state) ? [] : [input.state],
            terminalState: isTerminalPhase(input.state) ? input.state : null,
            nowMs: input.nowMs,
          })
        : null;
    const targets = yield* liveActivities.listTargets({ userId: input.deliveryUser.userId });
    const deliveriesByTarget = yield* Effect.forEach(
      targets,
      Effect.fnUntraced(function* (target) {
        if (target.platform === "android") {
          return [yield* fcmDeliveries.enqueue({ target, state: input.state })];
        }
        return yield* Effect.all(
          [
            apnsDeliveries.sendForTarget({
              target,
              aggregate: liveActivityAggregate,
              nowMs: input.nowMs,
            }),
            notificationOnlyAggregate === null
              ? Effect.succeed(null)
              : apnsDeliveries.sendPushNotificationForTarget({
                  target,
                  aggregate: notificationOnlyAggregate,
                }),
          ],
          { concurrency: 2 },
        );
      }),
      { concurrency: 4 },
    );
    return deliveriesByTarget.flat();
  });

  return AgentActivityPublisher.of({
    replayForLiveActivityRegistration: Effect.fn(
      "relay.agent_activity_publisher.replay_for_live_activity_registration",
    )(function* (input) {
      yield* Effect.annotateCurrentSpan({
        "relay.mobile.device_id": input.deviceId,
        "relay.operation": "replayForLiveActivityRegistration",
      });
      const { activeStates, targets } = yield* Effect.all(
        {
          activeStates: rows.listForUser({ userId: input.userId }),
          targets: liveActivities.listTargets({ userId: input.userId }),
        },
        { concurrency: 2 },
      );
      const target = targets.find((row) => row.device_id === input.deviceId) ?? null;
      if (target === null) {
        return null;
      }
      if (target.platform === "android") {
        return yield* fcmDeliveries.enqueue({ target, state: null, replay: true });
      }
      const now = yield* DateTime.now;
      const aggregate = makeAggregateState({
        activeStates,
        terminalState: null,
        nowMs: now.epochMilliseconds,
      });
      return yield* apnsDeliveries.sendForTarget({
        target,
        aggregate,
        nowMs: now.epochMilliseconds,
        replay: true,
      });
    }),
    // An idle card receives no more publishes to clear its expired finished rows.
    endIdleLiveActivities: Effect.gen(function* () {
      const now = yield* DateTime.now;
      const idleTargets = yield* liveActivities.listIdleArmedTargets({
        deliveredBefore: DateTime.formatIso(
          DateTime.subtract(now, { milliseconds: TERMINAL_AGENT_ACTIVITY_DISPLAY_TTL_MS }),
        ),
      });
      yield* Effect.annotateCurrentSpan({ "relay.live_activities.idle_count": idleTargets.length });
      yield* Effect.forEach(
        Object.entries(Arr.groupBy(idleTargets, (target) => target.user_id)),
        ([userId, candidates]) =>
          Effect.gen(function* () {
            const activeStates = yield* rows.listForUser({ userId });
            const aggregate = makeAggregateState({
              activeStates,
              terminalState: null,
              nowMs: now.epochMilliseconds,
            });
            if (aggregate !== null) return;
            const targets = yield* liveActivities.listTargets({ userId });
            const idleDeviceIds = new Set(candidates.map((target) => target.device_id));
            yield* Effect.forEach(
              targets.filter((target) => idleDeviceIds.has(target.device_id)),
              (target) =>
                apnsDeliveries
                  .sendForTarget({
                    target,
                    aggregate: null,
                    nowMs: now.epochMilliseconds,
                    replay: true,
                  })
                  .pipe(
                    Effect.catch((error) =>
                      Effect.logWarning("Failed to end idle Live Activity", {
                        deviceId: target.device_id,
                        error,
                      }),
                    ),
                  ),
              { discard: true },
            );
          }).pipe(
            Effect.catch((error) =>
              Effect.logWarning("Failed to list idle Live Activity content or targets", {
                userId,
                error,
              }),
            ),
          ),
        { concurrency: 4, discard: true },
      );
    }).pipe(Effect.withSpan("relay.agent_activity_publisher.end_idle_live_activities")),
    publish: Effect.fn("relay.agent_activity_publisher.publish")(function* (input) {
      yield* Effect.annotateCurrentSpan({
        "relay.environment_id": input.environmentId,
        "relay.thread_id": input.threadId,
        "relay.agent_activity.phase": input.state?.phase ?? "deleted",
      });
      if (input.state) {
        // Retain terminal rows until cron pruning so completed threads remain visible alongside active ones.
        yield* rows.upsert({
          environmentPublicKey: input.environmentPublicKey,
          state: input.state,
        });
      } else {
        yield* rows.remove({
          environmentId: input.environmentId,
          environmentPublicKey: input.environmentPublicKey,
          threadId: input.threadId,
        });
      }

      const deliveryUsers = yield* links.listDeliveryUsersForEnvironment({
        environmentId: input.environmentId,
        environmentPublicKey: input.environmentPublicKey,
      });
      const now = yield* DateTime.now;
      const deliveriesByUser = yield* Effect.forEach(
        deliveryUsers,
        (deliveryUser) =>
          publishForDeliveryUser({
            deliveryUser,
            state: input.state,
            nowMs: now.epochMilliseconds,
          }),
        { concurrency: 4 },
      );
      const deliveries = deliveriesByUser.flat();
      return {
        ok: true,
        deliveries: deliveries.filter(
          (delivery): delivery is RelayDeliveryResult => delivery !== null,
        ),
      };
    }),
  });
});

export const layer = Layer.effect(AgentActivityPublisher, make);