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/unstable/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 ApnsDeliveries from "./ApnsDeliveries.ts";import * as ApnsClient from "./ApnsClient.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([]),    markDelivery: () => Effect.void,    markStartQueued: () => Effect.void,    clearStartQueued: () => Effect.void,    invalidateDeliveryToken: () => Effect.void,    ...overrides,  };} function makeAgentActivityRows(  overrides: Partial<AgentActivityRows.AgentActivityRows["Service"]> = {},): AgentActivityRows.AgentActivityRows["Service"] {  return {    upsert: () => Effect.void,    remove: () => 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]);    },    ...overrides,  };} function makeEnvironmentLinks(  overrides: Partial<EnvironmentLinks.EnvironmentLinks["Service"]> = {},): EnvironmentLinks.EnvironmentLinks["Service"] {  return {    upsert: () => Effect.void,    listUsersForEnvironment: () => Effect.succeed(["dev:julius"]),    listDeliveryUsersForEnvironment: () =>      Effect.succeed([        {          userId: "dev:julius",          notificationsEnabled: true,          liveActivitiesEnabled: true,        },      ]),    listPublicKeysForEnvironment: () => Effect.succeed([]),    listForUser: () => Effect.succeed([]),    getForUser: () => Effect.succeed(null),    revokeForUser: () => Effect.succeed(false),    ...overrides,  };} function makeDeliveryAttempts(  overrides: Partial<DeliveryAttempts.DeliveryAttempts["Service"]> = {},): DeliveryAttempts.DeliveryAttempts["Service"] {  return {    record: () => Effect.void,    claimSourceJob: () => Effect.succeed("claimed"),    completeSourceJob: () => Effect.void,    ...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 makeRegistrationReplayLayer(input: {  readonly devices: Devices.Devices["Service"];  readonly liveActivities: LiveActivities.LiveActivities["Service"];  readonly queuedJobs: Array<SignedApnsDeliveryJob>;}) {  return MobileRegistrations.layer.pipe(    Layer.provide(AgentActivityPublisher.layer),    Layer.provide(ApnsDeliveries.layer.pipe(Layer.provide(ApnsClient.layer))),    Layer.provide(ApnsDeliveryQueue.layer.pipe(Layer.provide(NodeCryptoLayer.layer))),    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),    ...overrides,  };} describe("MobileRegistrations", () => {  it.effect("registers devices through the device persistence service", () => {    let registered: Parameters<Devices.Devices["Service"]["register"]>[0] | null = null;    let replayed:      | Parameters<          AgentActivityPublisher.AgentActivityPublisher["Service"]["replayForLiveActivityRegistration"]        >[0]      | null = null;     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({                    register: (input) =>                      Effect.sync(() => {                        registered = input;                      }),                  }),                ),                Layer.succeed(LiveActivities.LiveActivities, makeLiveActivities()),                Layer.succeed(                  AgentActivityPublisher.AgentActivityPublisher,                  makeAgentActivityPublisher({                    replayForLiveActivityRegistration: (input) =>                      Effect.sync(() => {                        replayed = input;                        return null;                      }),                  }),                ),              ),            ),          ),        ),      );       expect(result).toEqual({ ok: true });      expect(registered).toEqual({ userId: "dev:julius", registration: device });      expect(replayed).toEqual({        userId: "dev:julius",        deviceId: "device-1",      });    });  });   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(                  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("unregisters the current user's device", () => {    let unregistered: Parameters<Devices.Devices["Service"]["unregister"]>[0] | null = null;     return Effect.gen(function* () {      const result = yield* Effect.gen(function* () {        const registrations = yield* MobileRegistrations.MobileRegistrations;        return yield* registrations.unregisterDevice({          userId: "dev:julius",          deviceId: "device-1",        });      }).pipe(        Effect.provide(          MobileRegistrations.layer.pipe(            Layer.provide(              Layer.mergeAll(                Layer.succeed(                  Devices.Devices,                  makeDevices({                    unregister: (input) =>                      Effect.sync(() => {                        unregistered = input;                      }),                  }),                ),                Layer.succeed(LiveActivities.LiveActivities, makeLiveActivities()),                Layer.succeed(                  AgentActivityPublisher.AgentActivityPublisher,                  makeAgentActivityPublisher(),                ),              ),            ),          ),        ),      );       expect(result).toEqual({ ok: true });      expect(unregistered).toEqual({        userId: "dev:julius",        deviceId: "device-1",      });    });  });   it.effect("replays the latest activity state after registering a Live Activity token", () => {    const liveActivity = {      deviceId: "device-1" as const,      activityPushToken: "activity-token" as const,    };    let registered: Parameters<LiveActivities.LiveActivities["Service"]["register"]>[0] | null =      null;    let replayed:      | Parameters<          AgentActivityPublisher.AgentActivityPublisher["Service"]["replayForLiveActivityRegistration"]        >[0]      | null = null;     return Effect.gen(function* () {      const result = yield* Effect.gen(function* () {        const registrations = yield* MobileRegistrations.MobileRegistrations;        return yield* registrations.registerLiveActivity({          userId: "dev:julius",          payload: liveActivity,        });      }).pipe(        Effect.provide(          MobileRegistrations.layer.pipe(            Layer.provide(              Layer.mergeAll(                Layer.succeed(Devices.Devices, makeDevices()),                Layer.succeed(                  LiveActivities.LiveActivities,                  makeLiveActivities({                    register: (input) =>                      Effect.sync(() => {                        registered = input;                      }),                  }),                ),                Layer.succeed(                  AgentActivityPublisher.AgentActivityPublisher,                  makeAgentActivityPublisher({                    replayForLiveActivityRegistration: (input) =>                      Effect.sync(() => {                        replayed = input;                        return null;                      }),                  }),                ),              ),            ),          ),        ),      );       expect(result).toEqual({ ok: true });      expect(registered).toEqual({        userId: "dev:julius",        registration: liveActivity,      });      expect(replayed).toEqual({        userId: "dev:julius",        deviceId: "device-1",      });    });  });   it.effect(    "starts a remote Live Activity through the real publisher and APNs queue when a device registers after work is already active",    () => {      const queuedJobs: Array<SignedApnsDeliveryJob> = [];      const queuedStarts: Array<        Parameters<LiveActivities.LiveActivities["Service"]["markStartQueued"]>[0]      > = [];      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",              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,            },          ]),        markStartQueued: (input) =>          Effect.sync(() => {            queuedStarts.push(input);          }),      });       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).toEqual([          {            userId: "dev:julius",            registration: {              ...device,              pushToken: "apns-device-token",              pushToStartToken: "push-to-start-token",            },          },        ]);        expect(queuedStarts).toMatchObject([          {            userId: "dev:julius",            deviceId: "device-1",          },        ]);        expect(queuedJobs).toHaveLength(1);        expect(queuedJobs[0]?.payload).toMatchObject({          kind: "live_activity_start",          target: {            userId: "dev:julius",            deviceId: "device-1",            token: "push-to-start-token",          },          aggregate: {            title: "T3 Code",            subtitle: "Agent work in progress",            activeCount: 1,            activities: [              {                environmentId: "env-1",                threadId: "thread-1",                threadTitle: "Implement APNs",                status: "Working",              },            ],          },          notification: null,        });      }).pipe(Effect.provide(makeRegistrationReplayLayer({ devices, liveActivities, queuedJobs })));    },  );});