sailfork / t3code-github / infra/ relay/ src/ agentActivity/ MobileRegistrations.test.ts

import type {
  RelayAgentActivityState,
  RelayDeviceRegistrationRequest,
} from "@t3tools/contracts/relay";
import type { SignedApnsDeliveryJob } from "./apnsDeliveryJobs.ts";
import * as NodeCryptoLayer from "@effect/platform-node/NodeCrypto";
import { describe, expect, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Logger from "effect/Logger";
import * as Redacted from "effect/Redacted";
import { FetchHttpClient } from "effect/http";

import * as Devices from "./Devices.ts";
import * as AgentActivityRows from "./AgentActivityRows.ts";
import * as DeliveryAttempts from "./DeliveryAttempts.ts";
import * as EnvironmentLinks from "../environments/EnvironmentLinks.ts";
import * as LiveActivities from "./LiveActivities.ts";
import * as RelayConfiguration from "../Config.ts";
import * as AgentActivityPublisher from "./AgentActivityPublisher.ts";
import * as FcmDeliveries from "./FcmDeliveries.ts";

const layerPublisher = AgentActivityPublisher.layer.pipe(
  Layer.provide(
    Layer.succeed(FcmDeliveries.FcmDeliveries, {
      enqueue: () => Effect.succeed(null),
      process: () => Effect.void,
    }),
  ),
);
import * as ApnsDeliveries from "./ApnsDeliveries.ts";
import * as ApnsClient from "./ApnsClient.ts";
import * as ApnsProviderTokens from "./ApnsProviderTokens.ts";
import * as ApnsDeliveryQueue from "./ApnsDeliveryQueue.ts";
import * as MobileRegistrations from "./MobileRegistrations.ts";

const device: RelayDeviceRegistrationRequest = {
  deviceId: "device-1" as RelayDeviceRegistrationRequest["deviceId"],
  label: "Julius's iPhone",
  platform: "ios",
  iosMajorVersion: 18,
  appVersion: "1.0.0" as RelayDeviceRegistrationRequest["appVersion"],
  preferences: {
    liveActivitiesEnabled: true,
    notificationsEnabled: true,
    notifyOnApproval: true,
    notifyOnInput: true,
    notifyOnCompletion: true,
    notifyOnFailure: true,
  },
};

function makeDevices(
  overrides: Partial<Devices.Devices["Service"]> = {},
): Devices.Devices["Service"] {
  return {
    register: () => Effect.void,
    unregister: () => Effect.void,
    listForUser: () => Effect.succeed([]),
    ...overrides,
  };
}

function makeLiveActivities(
  overrides: Partial<LiveActivities.LiveActivities["Service"]> = {},
): LiveActivities.LiveActivities["Service"] {
  return {
    register: () => Effect.void,
    listTargets: () => Effect.succeed([]),
    listIdleArmedTargets: () => Effect.succeed([]),
    markDelivery: () => Effect.void,

    invalidateDeliveryToken: () => Effect.void,
    ...overrides,
  };
}

function makeAgentActivityRows(
  overrides: Partial<AgentActivityRows.AgentActivityRows["Service"]> = {},
): AgentActivityRows.AgentActivityRows["Service"] {
  return {
    upsert: () => Effect.void,
    remove: () => Effect.void,
    pruneTerminal: () => Effect.void,
    listForUser: () => {
      const activeState: RelayAgentActivityState = {
        environmentId: "env-1" as RelayAgentActivityState["environmentId"],
        threadId: "thread-1" as RelayAgentActivityState["threadId"],
        projectTitle: "Project",
        threadTitle: "Implement APNs",
        modelTitle: "gpt-5.4",
        phase: "running",
        headline: "Working",
        updatedAt: "1970-01-01T00:00:10.000Z",
        deepLink: "/env-1/thread-1",
      };
      return Effect.succeed([activeState]);
    },
    getForUserThread: () => Effect.succeed(null),
    ...overrides,
  };
}

function makeEnvironmentLinks(
  overrides: Partial<EnvironmentLinks.EnvironmentLinks["Service"]> = {},
): EnvironmentLinks.EnvironmentLinks["Service"] {
  return {
    upsert: () => Effect.void,
    listDeliveryUsersForEnvironment: () =>
      Effect.succeed([
        {
          userId: "dev:julius",
          notificationsEnabled: true,
          liveActivitiesEnabled: true,
        },
      ]),
    listForUser: () => Effect.succeed([]),
    getForUser: () => Effect.succeed(null),
    findActiveManagedForEnvironment: () => Effect.succeed([]),
    setHoldWebhooksWhileOffline: () => Effect.void,
    revokeForUser: () => Effect.succeed(false),
    ...overrides,
  };
}

function makeDeliveryAttempts(
  overrides: Partial<DeliveryAttempts.DeliveryAttempts["Service"]> = {},
): DeliveryAttempts.DeliveryAttempts["Service"] {
  return {
    claimSourceJob: () => Effect.succeed("claimed"),
    completeSourceJob: () => Effect.void,
    pruneExpired: Effect.succeed(0),
    ...overrides,
  };
}

const config = RelayConfiguration.RelayConfiguration.of({
  relayIssuer: "https://relay.example.test",
  apns: {
    environment: "sandbox",
    teamId: "team-id",
    keyId: "key-id",
    bundleId: "codes.t3.mobile",
    privateKey: Redacted.make("apns-private-key"),
  },
  clerkSecretKey: Redacted.make("clerk-secret"),
  clerkPublishableKey: "pk_test_test",
  clerkJwtAudience: "t3-code-relay",
  apnsDeliveryJobSigningSecret: Redacted.make("apns-job-secret"),
  cloudMintPrivateKey: Redacted.make("cloud-private-key"),
  cloudMintPublicKey: "cloud-public-key",
  managedEndpointBaseDomain: undefined,
  managedEndpointNamespace: undefined,
});

function layerRegistrationReplay(input: {
  readonly devices: Devices.Devices["Service"];
  readonly liveActivities: LiveActivities.LiveActivities["Service"];
  readonly queuedJobs: Array<SignedApnsDeliveryJob>;
}) {
  return MobileRegistrations.layer.pipe(
    Layer.provide(layerPublisher),
    Layer.provide(
      ApnsDeliveries.layer.pipe(
        Layer.provide(ApnsClient.layer.pipe(Layer.provide(ApnsProviderTokens.layer))),
      ),
    ),
    Layer.provide(ApnsDeliveryQueue.layer.pipe(Layer.provide(NodeCryptoLayer.layer))),
    Layer.provide(NodeCryptoLayer.layerMac),
    Layer.provide(
      Layer.mergeAll(
        Layer.succeed(Devices.Devices, input.devices),
        Layer.succeed(AgentActivityRows.AgentActivityRows, makeAgentActivityRows()),
        Layer.succeed(EnvironmentLinks.EnvironmentLinks, makeEnvironmentLinks()),
        Layer.succeed(LiveActivities.LiveActivities, input.liveActivities),
        Layer.succeed(DeliveryAttempts.DeliveryAttempts, makeDeliveryAttempts()),
        RelayConfiguration.layer(config),
        Layer.succeed(ApnsDeliveryQueue.ApnsDeliveryQueueSender, {
          send: (body) =>
            Effect.sync(() => {
              input.queuedJobs.push(body);
            }),
        }),
      ),
    ),
    Layer.provide(FetchHttpClient.layer),
  );
}

function makeAgentActivityPublisher(
  overrides: Partial<AgentActivityPublisher.AgentActivityPublisher["Service"]> = {},
): AgentActivityPublisher.AgentActivityPublisher["Service"] {
  return {
    publish: () => Effect.succeed({ ok: true, deliveries: [] }),
    replayForLiveActivityRegistration: () => Effect.succeed(null),
    endIdleLiveActivities: Effect.void,
    ...overrides,
  };
}

describe("MobileRegistrations", () => {
  it.effect("keeps device registration successful when activity replay fails", () => {
    const messages: unknown[] = [];
    const logger = Logger.make(({ message }) => {
      messages.push(message);
    });

    return Effect.gen(function* () {
      const result = yield* Effect.gen(function* () {
        const registrations = yield* MobileRegistrations.MobileRegistrations;
        return yield* registrations.registerDevice({ userId: "dev:julius", payload: device });
      }).pipe(
        Effect.provide(
          MobileRegistrations.layer.pipe(
            Layer.provide(
              Layer.mergeAll(
                Layer.succeed(Devices.Devices, makeDevices()),
                Layer.succeed(LiveActivities.LiveActivities, makeLiveActivities()),
                Layer.succeed(AgentActivityRows.AgentActivityRows, makeAgentActivityRows()),
                Layer.succeed(
                  AgentActivityPublisher.AgentActivityPublisher,
                  makeAgentActivityPublisher({
                    replayForLiveActivityRegistration: () =>
                      Effect.fail(
                        new AgentActivityRows.AgentActivityRowListPersistenceError({
                          userId: "dev:julius",
                          cause: "sensitive device replay detail",
                        }),
                      ),
                  }),
                ),
              ),
            ),
          ),
        ),
      );

      expect(result).toEqual({ ok: true });
      expect(messages).toContainEqual([
        "device registration activity replay failed",
        { errorTag: "AgentActivityRowListPersistenceError" },
      ]);
    }).pipe(Effect.provide(Logger.layer([logger], { mergeWithExisting: false })));
  });

  it.effect(
    "does not remotely start a Live Activity when a device registers after work is already active",
    () => {
      const queuedJobs: Array<SignedApnsDeliveryJob> = [];
      const registeredDevices: Array<Parameters<Devices.Devices["Service"]["register"]>[0]> = [];
      const devices = makeDevices({
        register: (input) =>
          Effect.sync(() => {
            registeredDevices.push(input);
          }),
      });
      const liveActivities = makeLiveActivities({
        listTargets: () =>
          Effect.succeed([
            {
              user_id: "dev:julius",
              device_id: "device-1",
              platform: "ios",
              ios_major_version: 18,
              app_version: "1.0.0",
              bundle_id: null,
              aps_environment: null,
              push_token: "apns-device-token",
              push_to_start_token: "push-to-start-token",
              preferences_json: JSON.stringify(device.preferences),
              activity_push_token: null,
              remote_start_queued_at: null,
              remote_started_at: null,
              ended_at: null,
              last_aggregate_json: null,
              last_live_activity_delivery_at: null,
            },
          ]),
      });

      return Effect.gen(function* () {
        const registrations = yield* MobileRegistrations.MobileRegistrations;
        const result = yield* registrations.registerDevice({
          userId: "dev:julius",
          payload: {
            ...device,
            pushToken: "apns-device-token",
            pushToStartToken: "push-to-start-token",
          },
        });

        expect(result).toEqual({ ok: true });
        expect(registeredDevices).toHaveLength(1);
        expect(queuedJobs).toEqual([]);
      }).pipe(Effect.provide(layerRegistrationReplay({ devices, liveActivities, queuedJobs })));
    },
  );
});