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

// @effect-diagnostics-next-line nodeBuiltinImport:off -- Effect's Crypto has no createPrivateKey.
import * as NodeCrypto from "node:crypto";

import { p256 } from "@noble/curves/nist";
import { sha256 } from "@noble/hashes/sha2";
import * as Effect from "effect/Effect";
import * as Base64Url from "effect/encoding/Base64Url";
import * as Redacted from "effect/Redacted";
import * as Result from "effect/Result";
import * as Schema from "effect/Schema";

import type { ApnsCredentials } from "../Config.ts";

export class ApnsJwtEncodingError extends Schema.TaggedError<ApnsJwtEncodingError>()(
  "ApnsJwtEncodingError",
  {
    component: Schema.Literals(["header", "payload"]),
    teamId: Schema.String,
    keyId: Schema.String,
    issuedAtUnixSeconds: Schema.Number,
    cause: Schema.Defect(),
  },
) {
  override get message(): string {
    return `Failed to encode APNs JWT ${this.component} for key ${this.keyId}.`;
  }
}

export class ApnsJwtSigningError extends Schema.TaggedError<ApnsJwtSigningError>()(
  "ApnsJwtSigningError",
  {
    teamId: Schema.String,
    keyId: Schema.String,
    issuedAtUnixSeconds: Schema.Number,
    cause: Schema.Defect(),
  },
) {
  override get message(): string {
    return `Failed to sign APNs JWT for key ${this.keyId}.`;
  }
}

export type ApnsJwtError = ApnsJwtEncodingError | ApnsJwtSigningError;

const encodeApnsJwtHeaderJson = Schema.encodeEffect(
  Schema.fromJsonString(
    Schema.Struct({
      alg: Schema.Literal("ES256"),
      kid: Schema.String,
    }),
  ),
);
const encodeApnsJwtPayloadJson = Schema.encodeEffect(
  Schema.fromJsonString(
    Schema.Struct({
      iss: Schema.String,
      iat: Schema.Number,
    }),
  ),
);

export interface ApnsJwtSigningInput {
  readonly teamId: ApnsCredentials["teamId"];
  readonly keyId: ApnsCredentials["keyId"];
  readonly privateKey: ApnsCredentials["privateKey"];
  readonly issuedAtUnixSeconds: number;
}

export const makeApnsJwt = Effect.fn("relay.apns.make_jwt")(function* (input: ApnsJwtSigningInput) {
  const headerJson = yield* encodeApnsJwtHeaderJson({ alg: "ES256", kid: input.keyId }).pipe(
    Effect.mapError(
      (cause) =>
        new ApnsJwtEncodingError({
          component: "header",
          teamId: input.teamId,
          keyId: input.keyId,
          issuedAtUnixSeconds: input.issuedAtUnixSeconds,
          cause,
        }),
    ),
  );
  const payloadJson = yield* encodeApnsJwtPayloadJson({
    iss: input.teamId,
    iat: input.issuedAtUnixSeconds,
  }).pipe(
    Effect.mapError(
      (cause) =>
        new ApnsJwtEncodingError({
          component: "payload",
          teamId: input.teamId,
          keyId: input.keyId,
          issuedAtUnixSeconds: input.issuedAtUnixSeconds,
          cause,
        }),
    ),
  );

  const privateKey = Redacted.value(input.privateKey);
  const header = Base64Url.encode(headerJson);
  const payload = Base64Url.encode(payloadJson);
  const signingInput = `${header}.${payload}`;

  return yield* Effect.try({
    try: () => {
      // RFC 6979 ES256 gives isolates identical JWTs at the same iat; Node crypto only extracts the scalar.
      const scalar = apnsSigningScalar(privateKey);
      const signature = p256
        .sign(sha256(new TextEncoder().encode(signingInput)), scalar, { prehash: false })
        .toCompactRawBytes();
      return `${signingInput}.${Base64Url.encode(signature)}`;
    },
    catch: (cause) =>
      new ApnsJwtSigningError({
        teamId: input.teamId,
        keyId: input.keyId,
        issuedAtUnixSeconds: input.issuedAtUnixSeconds,
        cause,
      }),
  });
});

const signingScalarCache = new Map<string, Uint8Array>();

function apnsSigningScalar(privateKeyPem: string): Uint8Array {
  const cached = signingScalarCache.get(privateKeyPem);
  if (cached) {
    return cached;
  }
  const jwk = NodeCrypto.createPrivateKey(privateKeyPem.replace(/\\n/g, "\n")).export({
    format: "jwk",
  });
  if (jwk.crv !== "P-256" || typeof jwk.d !== "string") {
    throw new Error("APNs signing key is not a P-256 private key.");
  }
  const scalar = Result.getOrThrowWith(
    Base64Url.decode(jwk.d),
    () => new Error("APNs signing key scalar is not valid base64url."),
  );
  signingScalarCache.set(privateKeyPem, scalar);
  return scalar;
}

export function apnsProviderTokenCacheKey(input: {
  readonly teamId: string;
  readonly keyId: string;
  readonly privateKey: ApnsCredentials["privateKey"];
}): string {
  const keyFingerprint = NodeCrypto.createHash("sha256")
    .update(Redacted.value(input.privateKey))
    .digest("hex")
    .slice(0, 16);
  return `${input.teamId}:${input.keyId}:${keyFingerprint}`;
}