Skip to content
TypeScript
13.7 KB
Raw Blame
#!/usr/bin/env node

import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as Config from "effect/Config";
import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Logger from "effect/Logger";
import * as Option from "effect/Option";
import * as Redacted from "effect/Redacted";
import * as Schedule from "effect/Schedule";
import * as Schema from "effect/Schema";
import { Argument, Command, Flag } from "effect/cli";
import {
  FetchHttpClient,
  HttpClient,
  HttpClientError,
  HttpClientRequest,
  HttpClientResponse,
} from "effect/http";

export type DiscordReleaseTarget = "prerelease" | "latest";

export interface DiscordReleaseAnnouncementOptions {
  readonly target: DiscordReleaseTarget;
  readonly roleId: string;
  readonly releaseName: string;
  readonly version: string;
  readonly tag: string;
  readonly releaseUrl: URL;
  readonly timestamp: string;
  readonly releaseNotes?: string;
}

interface DiscordWebhookPayload {
  readonly content: string;
  readonly allowed_mentions: {
    readonly parse: ReadonlyArray<never>;
    readonly roles: ReadonlyArray<string>;
  };
  readonly embeds: ReadonlyArray<{
    readonly title: string;
    readonly url: string;
    readonly description: string;
    readonly color: number;
    readonly footer: { readonly text: string };
    readonly timestamp: string;
  }>;
}

const DISCORD_RELEASE_TARGETS = ["prerelease", "latest"] as const;
const DiscordRoleIdSchema = Schema.String.check(Schema.isPattern(/^\d+$/));
const DiscordWebhookUrl = Config.Redacted("DISCORD_WEBHOOK_URL").pipe(
  Effect.flatMap((value) =>
    Effect.try({
      try: () => new URL(Redacted.value(value)),
      catch: () => new DiscordReleaseWebhookConfigurationError({}),
    }),
  ),
);

export class DiscordReleaseWebhookConfigurationError extends Schema.TaggedError<DiscordReleaseWebhookConfigurationError>()(
  "DiscordReleaseWebhookConfigurationError",
  {},
) {
  override get message(): string {
    return "DISCORD_WEBHOOK_URL must be a valid URL.";
  }
}

const discordReleaseErrorContext = {
  target: Schema.Literals(["prerelease", "latest"]),
  releaseName: Schema.String,
  version: Schema.String,
  tag: Schema.String,
  releaseUrl: Schema.String,
  webhookOrigin: Schema.String,
  webhookPathnameSegmentCount: Schema.Number,
  contentLength: Schema.Number,
  embedCount: Schema.Number,
  allowedRoleMentionCount: Schema.Number,
  hasRoleMentionSyntax: Schema.Boolean,
};

export class DiscordReleaseWebhookRequestError extends Schema.TaggedError<DiscordReleaseWebhookRequestError>()(
  "DiscordReleaseWebhookRequestError",
  {
    ...discordReleaseErrorContext,
    reason: Schema.String,
  },
) {
  override get message(): string {
    return `Failed to post Discord ${this.target} release announcement for "${this.tag}" to ${this.webhookOrigin}.`;
  }
}

export class DiscordReleaseWebhookResponseError extends Schema.TaggedError<DiscordReleaseWebhookResponseError>()(
  "DiscordReleaseWebhookResponseError",
  {
    ...discordReleaseErrorContext,
    status: Schema.Number,
  },
) {
  override get message(): string {
    return `Discord ${this.target} release webhook for "${this.tag}" returned status ${this.status}.`;
  }
}

const targetColors = {
  prerelease: 0x5865f2,
  latest: 0x2ecc71,
} as const satisfies Record<DiscordReleaseTarget, number>;

function describeWebhookUrl(webhookUrl: URL) {
  return {
    configured: true,
    origin: webhookUrl.origin,
    pathnameSegmentCount: webhookUrl.pathname.split("/").filter(Boolean).length,
  } as const;
}

function summarizePayload(payload: DiscordWebhookPayload) {
  return {
    contentLength: payload.content.length,
    embedCount: payload.embeds.length,
    allowedRoleMentionCount: payload.allowed_mentions.roles.length,
    hasRoleMentionSyntax: payload.content.includes("<@&"),
  } as const;
}

const suppressMentions = (text: string) =>
  text.replace(/@(everyone|here)\b|<@[!&]?\d+>/g, (mention) => mention.replace("@", "@\u200b"));

const escapeLinkLabel = (text: string) => text.replace(/[\\[\]]/g, "\\$&");

/** GitHub links `(#123)` on the release page; Discord needs the link written out. */
function linkPullRequestNumbers(notes: string, releaseUrl: URL) {
  const repositoryUrl = releaseUrl.href.split("/releases/")[0];
  return notes.replace(/#(\d+)\b/g, `[#$1](${repositoryUrl}/pull/$1)`);
}

function formatReleaseNotes(notes: string) {
  return notes
    .replace(
      /^([*-] )(.+?)(?: by @([\w-]+(?:\[bot\])?))? in (https:\/\/github\.com\/[\w.-]+\/[\w.-]+\/pull\/\d+)[ \t]*\r?$/gm,
      (
        _entry,
        bullet: string,
        title: string,
        author: string | undefined,
        pullRequestUrl: string,
      ) => {
        const change = `${bullet}[${escapeLinkLabel(title)}](${pullRequestUrl})`;
        if (!author) return change;
        const profile = author.endsWith("[bot]") ? `apps/${author.slice(0, -5)}` : author;
        return `${change} by [@${escapeLinkLabel(author)}](https://github.com/${profile})`;
      },
    )
    .replace(
      /^(?:\*\*)?Full Changelog(?:\*\*)?: (https:\/\/github\.com\/[\w.-]+\/[\w.-]+\/compare\/\S+)[ \t]*\r?$/gm,
      "[Full Changelog]($1)",
    );
}

function splitDescription(text: string, limit: number) {
  const chunks: string[] = [];
  while (text.length > limit) {
    const newline = text.lastIndexOf("\n", limit - 1);
    const space = text.lastIndexOf(" ", limit - 1);
    let end = newline > 0 ? newline + 1 : space > 0 ? space + 1 : limit;
    const lastCodeUnit = text.charCodeAt(end - 1);
    if (lastCodeUnit >= 0xd800 && lastCodeUnit <= 0xdbff) end -= 1;
    chunks.push(text.slice(0, end));
    text = text.slice(end);
  }
  chunks.push(text);
  return chunks;
}

export const buildDiscordReleaseAnnouncement = (
  options: DiscordReleaseAnnouncementOptions,
): ReadonlyArray<DiscordWebhookPayload> => {
  const releaseName = suppressMentions(options.releaseName);
  const version = suppressMentions(options.version);
  const footerText = `v${version.replace(/^v/, "")}`;
  const content = `-# <@&${options.roleId}>`;
  if (!/^\d+$/.test(options.roleId)) throw new RangeError("Invalid Discord release role ID.");
  if (releaseName.length > 256)
    throw new RangeError("Discord release title exceeds 256 characters.");
  if (content.length > 2000)
    throw new RangeError("Discord release content exceeds 2000 characters.");
  if (footerText.length > 2048) {
    throw new RangeError("Discord release footer exceeds 2048 characters.");
  }

  const intro =
    options.target === "prerelease"
      ? "A new T3 Code prerelease is available for nightly testers."
      : `[View full release notes on GitHub](${options.releaseUrl.href})`;
  // Generated summaries fold the full list under <details>, which Discord cannot render.
  const [summary = "", folded] = (options.releaseNotes ?? "").split(/^<details>/m);
  const notes =
    options.target === "prerelease"
      ? suppressMentions(
          folded === undefined
            ? formatReleaseNotes(summary.trim())
            : `${linkPullRequestNumbers(summary.trim(), options.releaseUrl)}\n\n[Full changelog](${options.releaseUrl.href})`,
        )
      : "";
  const description = notes ? `${intro}\n\n${notes}` : intro;
  // Separate embeds avoid URL deduplication; reserve title and footer space within Discord's 6000-character limit.
  const limit = Math.min(4096, 6000 - 256 - footerText.length);
  const descriptions = splitDescription(description, limit);

  return descriptions.map((description, index) => ({
    content: index === 0 ? content : "",
    allowed_mentions: {
      parse: [],
      roles: index === 0 ? [options.roleId] : [],
    },
    embeds: [
      {
        title:
          index === 0 ? releaseName : `Changelog continued (${index + 1}/${descriptions.length})`,
        url: options.releaseUrl.href,
        description,
        color: targetColors[options.target],
        footer: { text: footerText },
        timestamp: options.timestamp,
      },
    ],
  }));
};

export const postDiscordWebhook = Effect.fn("postDiscordWebhook")(function* (
  webhookUrl: URL,
  payload: DiscordWebhookPayload,
  announcement: DiscordReleaseAnnouncementOptions,
) {
  const requestUrl = new URL(webhookUrl);
  requestUrl.searchParams.set("wait", "true");
  const httpClient = (yield* HttpClient.HttpClient).pipe(
    HttpClient.retryTransient({
      retryOn: "errors-and-responses",
      times: 3,
      schedule: Schedule.recurs(3).pipe(
        Schedule.addDelay(
          (
            metadata: Schedule.Metadata<
              number,
              HttpClientResponse.HttpClientResponse | HttpClientError.HttpClientError
            >,
          ) => {
            const response = !HttpClientError.isHttpClientError(metadata.input)
              ? metadata.input
              : metadata.input.reason._tag === "StatusCodeError"
                ? metadata.input.reason.response
                : undefined;
            const retryAfterSeconds = Number(response?.headers["retry-after"]);
            return Effect.succeed(
              Number.isFinite(retryAfterSeconds) && retryAfterSeconds >= 0
                ? retryAfterSeconds * 1000
                : 1000,
            );
          },
        ),
      ),
    }),
  );

  yield* Effect.logInfo("discord webhook request dispatching").pipe(
    Effect.annotateLogs({
      ...describeWebhookUrl(webhookUrl),
      ...summarizePayload(payload),
    }),
  );

  const errorContext = {
    target: announcement.target,
    releaseName: announcement.releaseName,
    version: announcement.version,
    tag: announcement.tag,
    releaseUrl: announcement.releaseUrl.href,
    webhookOrigin: webhookUrl.origin,
    webhookPathnameSegmentCount: webhookUrl.pathname.split("/").filter(Boolean).length,
    ...summarizePayload(payload),
  } as const;

  const response = yield* HttpClientRequest.post(requestUrl).pipe(
    HttpClientRequest.bodyJson(payload),
    Effect.flatMap(httpClient.execute),
    Effect.timeout("1 minute"),
    Effect.mapError(
      (error) =>
        new DiscordReleaseWebhookRequestError({
          ...errorContext,
          // HTTP errors retain the request URL, including the webhook token.
          reason: error._tag === "HttpClientError" ? error.reason._tag : error._tag,
        }),
    ),
  );

  yield* Effect.logInfo("discord webhook response received").pipe(
    Effect.annotateLogs({
      status: response.status,
      ok: response.status >= 200 && response.status < 300,
    }),
  );

  yield* HttpClientResponse.filterStatusOk(response).pipe(
    Effect.mapError(
      () =>
        new DiscordReleaseWebhookResponseError({
          ...errorContext,
          status: response.status,
        }),
    ),
  );
});

export const notifyDiscordReleaseCommand = Command.make(
  "notify-discord-release",
  {
    target: Argument.Literals("target", DISCORD_RELEASE_TARGETS).pipe(
      Argument.withDescription("Discord announcement target: prerelease or latest."),
    ),
    roleId: Flag.String("role-id").pipe(
      Flag.withSchema(DiscordRoleIdSchema),
      Flag.withDescription("Discord role ID to mention in the release announcement."),
    ),
    releaseName: Flag.String("release-name").pipe(
      Flag.withSchema(Schema.NonEmptyString),
      Flag.withDescription("Human-readable release name."),
    ),
    releaseVersion: Flag.String("release-version").pipe(
      Flag.withSchema(Schema.NonEmptyString),
      Flag.withDescription("Release version."),
    ),
    tag: Flag.String("tag").pipe(
      Flag.withSchema(Schema.NonEmptyString),
      Flag.withDescription("Git tag for the release."),
    ),
    releaseUrl: Flag.String("release-url").pipe(
      Flag.withSchema(Schema.URLFromString),
      Flag.withDescription("Public GitHub release URL."),
    ),
    releaseNotesFile: Flag.String("release-notes-file").pipe(
      Flag.optional,
      Flag.withDescription("File containing the published GitHub release notes."),
    ),
  },
  ({ target, roleId, releaseName, releaseVersion, tag, releaseUrl, releaseNotesFile }) =>
    Effect.gen(function* () {
      yield* Effect.logInfo("discord release announcement starting").pipe(
        Effect.annotateLogs({
          target,
          roleIdProvided: roleId.length > 0,
          roleIdLength: roleId.length,
          releaseName,
          version: releaseVersion,
          tag,
          releaseUrl,
        }),
      );

      const webhookUrl = yield* DiscordWebhookUrl;
      const fs = yield* FileSystem.FileSystem;
      const releaseNotes =
        target === "prerelease" && Option.isSome(releaseNotesFile)
          ? yield* fs.readFileString(releaseNotesFile.value)
          : "";
      const timestamp = DateTime.formatIso(yield* DateTime.now);
      const announcement = {
        target,
        roleId,
        releaseName,
        version: releaseVersion,
        tag,
        releaseUrl,
        timestamp,
        releaseNotes,
      } satisfies DiscordReleaseAnnouncementOptions;
      const payloads = yield* Effect.sync(() => buildDiscordReleaseAnnouncement(announcement));

      yield* Effect.logInfo("discord release announcement payloads built").pipe(
        Effect.annotateLogs({ messageCount: payloads.length }),
      );
      for (const payload of payloads) {
        yield* postDiscordWebhook(webhookUrl, payload, announcement);
      }
      yield* Effect.logInfo("discord release announcement completed");
    }),
).pipe(Command.withDescription("Post a T3 Code release announcement to Discord."));

if (import.meta.main) {
  Command.run(notifyDiscordReleaseCommand, { version: "0.0.0" }).pipe(
    Effect.provide(
      Layer.mergeAll(
        Logger.layer([Logger.consolePretty()]),
        NodeServices.layer,
        FetchHttpClient.layer,
      ),
    ),
    NodeRuntime.runMain,
  );
}