The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import type { DesktopUpdateChannel, DesktopUpdateReleaseNote } from "@t3tools/contracts"; |
| 2 | |
| 3 | import { desktopUpdateChannelOf } from "@t3tools/shared/cliRelease"; |
| 4 | |
| 5 | interface ElectronReleaseNoteInfo { |
| 6 | readonly version: string; |
| 7 | readonly note: string | null | undefined; |
| 8 | } |
| 9 | |
| 10 | function isElectronReleaseNoteInfo(value: unknown): value is ElectronReleaseNoteInfo { |
| 11 | if (typeof value !== "object" || value === null) return false; |
| 12 | const candidate = value as { readonly version?: unknown; readonly note?: unknown }; |
| 13 | return ( |
| 14 | typeof candidate.version === "string" && |
| 15 | (typeof candidate.note === "string" || candidate.note === null || candidate.note === undefined) |
| 16 | ); |
| 17 | } |
| 18 | |
| 19 | const MAX_RELEASE_NOTE_GROUPS = 6; |
| 20 | const MAX_RELEASE_NOTE_ITEMS_PER_GROUP = 8; |
| 21 | const MAX_RELEASE_NOTE_ITEM_LENGTH = 220; |
| 22 | |
| 23 | const HTML_ENTITY_REPLACEMENTS: ReadonlyMap<string, string> = new Map([ |
| 24 | ["amp", "&"], |
| 25 | ["apos", "'"], |
| 26 | ["gt", ">"], |
| 27 | ["lt", "<"], |
| 28 | ["nbsp", " "], |
| 29 | ["quot", '"'], |
| 30 | ]); |
| 31 | |
| 32 | function decodeCodePoint(codePoint: number, entity: string): string { |
| 33 | if (!Number.isInteger(codePoint) || codePoint < 0 || codePoint > 0x10ffff) { |
| 34 | return `&${entity};`; |
| 35 | } |
| 36 | return String.fromCodePoint(codePoint); |
| 37 | } |
| 38 | |
| 39 | function decodeHtmlEntity(entity: string): string { |
| 40 | const named = HTML_ENTITY_REPLACEMENTS.get(entity); |
| 41 | if (named) return named; |
| 42 | if (entity.startsWith("#x")) { |
| 43 | return decodeCodePoint(Number.parseInt(entity.slice(2), 16), entity); |
| 44 | } |
| 45 | if (entity.startsWith("#")) { |
| 46 | return decodeCodePoint(Number.parseInt(entity.slice(1), 10), entity); |
| 47 | } |
| 48 | return `&${entity};`; |
| 49 | } |
| 50 | |
| 51 | function decodeHtmlEntities(input: string): string { |
| 52 | return input.replace(/&([a-zA-Z]+|#\d+|#x[0-9a-fA-F]+);/g, (_, entity: string) => |
| 53 | decodeHtmlEntity(entity), |
| 54 | ); |
| 55 | } |
| 56 | |
| 57 | function stripMarkup(input: string, keepBold = false): string { |
| 58 | const markdown = decodeHtmlEntities( |
| 59 | input |
| 60 | .replace(/<br\s*\/?>/gi, "\n") |
| 61 | .replace(/<li\b[^>]*>/gi, "\n- ") |
| 62 | .replace(/<h([1-6])\b[^>]*>/gi, (_, level: string) => `\n${"#".repeat(Number(level))} `) |
| 63 | .replace(/<\/(?:p|div|li|h[1-6]|ul|ol|blockquote)>/gi, "\n") |
| 64 | .replace(/<\/?(?:strong|b)\b[^>]*>/gi, "**") |
| 65 | .replace(/<[^>]*>/g, "") |
| 66 | .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1"), |
| 67 | ); |
| 68 | return keepBold ? markdown : markdown.replace(/\*\*([^*]+)\*\*/g, "$1"); |
| 69 | } |
| 70 | |
| 71 | function truncateReleaseNoteItem(item: string): string { |
| 72 | if (item.length <= MAX_RELEASE_NOTE_ITEM_LENGTH) return item; |
| 73 | return `${item.slice(0, MAX_RELEASE_NOTE_ITEM_LENGTH - 3).trimEnd()}...`; |
| 74 | } |
| 75 | |
| 76 | function normalizeReleaseNoteLine(line: string): string { |
| 77 | return line |
| 78 | .toLowerCase() |
| 79 | .replace(/[*_`#]/g, "") |
| 80 | .trim(); |
| 81 | } |
| 82 | |
| 83 | function isIgnoredReleaseNoteLine(line: string): boolean { |
| 84 | const normalized = normalizeReleaseNoteLine(line); |
| 85 | return ( |
| 86 | normalized === "" || |
| 87 | normalized === "what's changed" || |
| 88 | normalized === "whats changed" || |
| 89 | normalized.startsWith("compare: ") || |
| 90 | normalized.includes("/compare/") || |
| 91 | // The feed's HTML footer loses its compare URL to stripMarkup, leaving only the range. |
| 92 | /^full changelog: \S+\.\.\.\S+$/.test(normalized) |
| 93 | ); |
| 94 | } |
| 95 | |
| 96 | type ExtractedReleaseNoteItems = Omit<DesktopUpdateReleaseNote, "version" | "releasedAt">; |
| 97 | |
| 98 | /** Older generated notes have a highlights paragraph followed by a separate list of fixes. */ |
| 99 | function extractReleaseNoteSummary(summary: string): ExtractedReleaseNoteItems { |
| 100 | let stats: string | undefined; |
| 101 | let footer: string | undefined; |
| 102 | const intro: string[] = []; |
| 103 | const items: string[] = []; |
| 104 | for (const rawLine of stripMarkup(summary, true).split("\n")) { |
| 105 | const line = rawLine |
| 106 | .trim() |
| 107 | .replace(/\s+/g, " ") |
| 108 | .replace(/\s*\((?:#\d+(?:,\s*)?)+\)\.?$/, "") |
| 109 | .trim(); |
| 110 | const plain = line.replace(/\*\*([^*]+)\*\*/g, "$1"); |
| 111 | if (/^### Plus \d+ more /.test(plain)) { |
| 112 | footer = plain.slice(4); |
| 113 | continue; |
| 114 | } |
| 115 | if (plain === "" || /^#{1,6}\s+/.test(plain)) continue; |
| 116 | if (stats === undefined && /^v\S+ · /.test(plain)) { |
| 117 | stats = plain.slice(plain.indexOf(" · ") + 3); |
| 118 | continue; |
| 119 | } |
| 120 | if (/^[-*]\s+/.test(line)) { |
| 121 | items.push(line.replace(/^[-*]\s+/, "")); |
| 122 | } else { |
| 123 | intro.push(plain); |
| 124 | } |
| 125 | } |
| 126 | return { |
| 127 | items, |
| 128 | totalItems: items.length + intro.length, |
| 129 | ...(intro.length > 0 ? { intro: intro.join(" ") } : {}), |
| 130 | ...(stats ? { stats } : {}), |
| 131 | ...(footer ? { footer } : {}), |
| 132 | }; |
| 133 | } |
| 134 | |
| 135 | function extractReleaseNoteItems(note: string | null | undefined): ExtractedReleaseNoteItems { |
| 136 | if (!note) return { items: [], totalItems: 0 }; |
| 137 | |
| 138 | // Generated summaries fold GitHub's full list under this exact <details> block. |
| 139 | const summaryEnd = note.search(/<details>\s*<summary>\s*Full changelog\s*<\/summary>/i); |
| 140 | if (summaryEnd >= 0) return extractReleaseNoteSummary(note.slice(0, summaryEnd)); |
| 141 | const items: string[] = []; |
| 142 | let totalItems = 0; |
| 143 | for (const rawLine of stripMarkup(note).split("\n")) { |
| 144 | const item = rawLine |
| 145 | .trim() |
| 146 | .replace(/^[-*]\s+/, "") |
| 147 | .replace(/^\d+[.)]\s+/, "") |
| 148 | .replace(/\s+/g, " "); |
| 149 | const normalized = normalizeReleaseNoteLine(item); |
| 150 | if (normalized === "new contributors" || normalized === "full changelog") break; |
| 151 | if (/^#{1,6}\s+/.test(item)) continue; |
| 152 | if (isIgnoredReleaseNoteLine(item)) continue; |
| 153 | totalItems += 1; |
| 154 | items.push(truncateReleaseNoteItem(item)); |
| 155 | if (items.length > MAX_RELEASE_NOTE_ITEMS_PER_GROUP) items.shift(); |
| 156 | } |
| 157 | return { items: items.toReversed(), totalItems }; |
| 158 | } |
| 159 | |
| 160 | // The update feed dates only the offered version; prerelease versions carry their UTC build day. |
| 161 | const PRERELEASE_BUILD_DAY = /-(?:nightly|preview)\.(\d{4})(\d{2})(\d{2})\.\d+$/; |
| 162 | |
| 163 | function resolveReleasedAt(version: string, offeredVersion: string, releaseDate?: string) { |
| 164 | if (version === offeredVersion && releaseDate) return releaseDate; |
| 165 | const day = PRERELEASE_BUILD_DAY.exec(version); |
| 166 | return day ? `${day[1]}-${day[2]}-${day[3]}` : undefined; |
| 167 | } |
| 168 | |
| 169 | interface NormalizedDesktopUpdateReleaseNotes { |
| 170 | readonly releaseNotes: ReadonlyArray<DesktopUpdateReleaseNote>; |
| 171 | readonly omittedReleaseCount: number; |
| 172 | } |
| 173 | |
| 174 | const escapeRegExp = (value: string) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); |
| 175 | |
| 176 | /** |
| 177 | * Untagged notes come from the feed entry named by releaseName, which is the newest entry when the |
| 178 | * offered release is not on the feed's first page. Keep them only when that entry is the offered one. |
| 179 | */ |
| 180 | export function releaseNotesOfOfferedVersion(info: { |
| 181 | readonly version: string; |
| 182 | readonly releaseNotes?: unknown; |
| 183 | readonly releaseName?: string | null | undefined; |
| 184 | }): unknown { |
| 185 | if (typeof info.releaseNotes !== "string" || !info.releaseName) return info.releaseNotes; |
| 186 | const namesVersion = new RegExp(`(?:^|[^\\w.-])v?${escapeRegExp(info.version)}(?![\\w.-])`); |
| 187 | return namesVersion.test(info.releaseName) ? info.releaseNotes : undefined; |
| 188 | } |
| 189 | |
| 190 | /** fullChangelog includes all greater semvers, so preview cuts sort above nightlies of the same base version. */ |
| 191 | export function normalizeDesktopUpdateReleaseNotes( |
| 192 | releaseNotes: unknown, |
| 193 | fallbackVersion: string, |
| 194 | channel: DesktopUpdateChannel, |
| 195 | releaseDate?: string, |
| 196 | ): NormalizedDesktopUpdateReleaseNotes { |
| 197 | const rawNotes = ( |
| 198 | typeof releaseNotes === "string" |
| 199 | ? [{ version: fallbackVersion, note: releaseNotes }] |
| 200 | : Array.isArray(releaseNotes) |
| 201 | ? releaseNotes.filter(isElectronReleaseNoteInfo) |
| 202 | : [] |
| 203 | ).filter((entry) => desktopUpdateChannelOf(entry.version) === channel); |
| 204 | |
| 205 | const normalizedNotes = rawNotes.flatMap((entry) => { |
| 206 | const note = extractReleaseNoteItems(entry.note); |
| 207 | if (note.totalItems === 0 && !note.stats) return []; |
| 208 | const releasedAt = resolveReleasedAt(entry.version, fallbackVersion, releaseDate); |
| 209 | return [ |
| 210 | { |
| 211 | version: entry.version, |
| 212 | ...note, |
| 213 | ...(releasedAt ? { releasedAt } : {}), |
| 214 | }, |
| 215 | ]; |
| 216 | }); |
| 217 | |
| 218 | return { |
| 219 | releaseNotes: normalizedNotes.slice(0, MAX_RELEASE_NOTE_GROUPS), |
| 220 | omittedReleaseCount: Math.max(0, normalizedNotes.length - MAX_RELEASE_NOTE_GROUPS), |
| 221 | }; |
| 222 | } |