Open History to see the last commit
1import { createHash } from 'node:crypto'
2import { execFileSync } from 'node:child_process'
3import { createWriteStream } from 'node:fs'
4import { mkdtemp, rm } from 'node:fs/promises'
5import { tmpdir } from 'node:os'
6import { join, resolve } from 'node:path'
7import { Readable, Transform } from 'node:stream'
8import { pipeline } from 'node:stream/promises'
9import { fileURLToPath } from 'node:url'
10
11class NotAvailable extends Error {
12 constructor(message, retryAfterMs = 0) {
13 super(message)
14 this.retryAfterMs = retryAfterMs
15 }
16}
17
18async function fetchAvailable(url, fetchImpl, requestTimeoutMs) {
19 let response
20 try {
21 response = await fetchImpl(url, {
22 signal: AbortSignal.timeout(requestTimeoutMs),
23 })
24 } catch (error) {
25 throw new NotAvailable(`${url}: ${error.message}`)
26 }
27 if (
28 response.status === 404 ||
29 response.status === 429 ||
30 response.status >= 500
31 ) {
32 const retryAfter = response.headers.get('retry-after')
33 const retryAfterMs =
34 retryAfter && /^\d+$/.test(retryAfter)
35 ? Number(retryAfter) * 1000
36 : retryAfter
37 ? Math.max(0, Date.parse(retryAfter) - Date.now())
38 : 0
39 await response.body?.cancel()
40 throw new NotAvailable(`${url}: HTTP ${response.status}`, retryAfterMs)
41 }
42 if (!response.ok) {
43 await response.body?.cancel()
44 throw new Error(`${url}: HTTP ${response.status}`)
45 }
46 return response
47}
48
49async function verifyPackage(pkg, { registry, fetchImpl, requestTimeoutMs }) {
50 const metadataURL = `${registry.origin}/${encodeURIComponent(pkg.name)}/${encodeURIComponent(pkg.version)}`
51 const metadataResponse = await fetchAvailable(
52 metadataURL,
53 fetchImpl,
54 requestTimeoutMs,
55 )
56 let metadata
57 try {
58 metadata = await metadataResponse.json()
59 } catch (error) {
60 throw new NotAvailable(`${metadataURL}: ${error.message}`)
61 }
62 if (metadata.name !== pkg.name || metadata.version !== pkg.version) {
63 throw new Error(`Registry identity mismatch for ${pkg.name}@${pkg.version}`)
64 }
65 const integrity = metadata.dist?.integrity
66 ?.split(/\s+/)
67 .find((value) => /^sha512-[A-Za-z0-9+/]+={0,2}$/.test(value))
68 if (!integrity)
69 throw new Error(`Missing SHA512 integrity for ${pkg.name}@${pkg.version}`)
70 const tarballURL = new URL(metadata.dist.tarball)
71 if (tarballURL.origin !== registry.origin) {
72 throw new Error(`Unexpected tarball origin for ${pkg.name}@${pkg.version}`)
73 }
74 const response = await fetchAvailable(tarballURL, fetchImpl, requestTimeoutMs)
75 if (!response.body)
76 throw new Error(`Empty tarball for ${pkg.name}@${pkg.version}`)
77 const directory = await mkdtemp(join(tmpdir(), 'tanstack-release-'))
78 const archive = join(directory, 'package.tgz')
79 const hash = createHash('sha512')
80 let bytes = 0
81 try {
82 try {
83 await pipeline(
84 Readable.fromWeb(response.body),
85 new Transform({
86 transform(chunk, _encoding, callback) {
87 hash.update(chunk)
88 bytes += chunk.length
89 callback(null, chunk)
90 },
91 }),
92 createWriteStream(archive),
93 )
94 } catch (error) {
95 if (
96 error instanceof TypeError ||
97 ['AbortError', 'TimeoutError'].includes(error.name)
98 ) {
99 throw new NotAvailable(
100 `Tarball download interrupted for ${pkg.name}@${pkg.version}: ${error.message}`,
101 )
102 }
103 throw error
104 }
105 if (`sha512-${hash.digest('base64')}` !== integrity) {
106 throw new Error(
107 `Tarball integrity mismatch for ${pkg.name}@${pkg.version}`,
108 )
109 }
110 const packed = JSON.parse(
111 execFileSync('tar', ['-xOzf', archive, 'package/package.json'], {
112 encoding: 'utf8',
113 maxBuffer: 1024 * 1024,
114 }),
115 )
116 if (packed.name !== pkg.name || packed.version !== pkg.version) {
117 throw new Error(`Packed identity mismatch for ${pkg.name}@${pkg.version}`)
118 }
119 return { ...pkg, integrity, bytes }
120 } finally {
121 await rm(directory, { recursive: true, force: true })
122 }
123}
124
125export async function verifyReleaseArtifacts(
126 packages,
127 {
128 registryURL = 'https://registry.npmjs.org',
129 fetchImpl = fetch,
130 now = Date.now,
131 sleep = (ms) => new Promise((done) => setTimeout(done, ms)),
132 timeoutMs = 20 * 60 * 1000,
133 pollMs = 15 * 1000,
134 log = console.log,
135 } = {},
136) {
137 if (
138 !Array.isArray(packages) ||
139 !packages.length ||
140 packages.some(
141 (pkg) =>
142 !pkg ||
143 typeof pkg.name !== 'string' ||
144 !pkg.name ||
145 typeof pkg.version !== 'string' ||
146 !pkg.version,
147 )
148 ) {
149 throw new Error('Expected published package names and versions')
150 }
151 if (
152 !Number.isFinite(timeoutMs) ||
153 timeoutMs <= 0 ||
154 !Number.isFinite(pollMs) ||
155 pollMs <= 0
156 ) {
157 throw new Error('Verification timeout and poll interval must be positive')
158 }
159 const registry = new URL(registryURL)
160 if (registry.protocol !== 'https:')
161 throw new Error('The registry must use HTTPS')
162 const deadline = now() + timeoutMs
163 const pending = new Map(
164 packages.map((pkg) => [`${pkg.name}@${pkg.version}`, pkg]),
165 )
166 const verified = []
167 let lastReasons = []
168 while (pending.size) {
169 let retryAfterMs = pollMs
170 lastReasons = []
171 for (const [id, pkg] of pending) {
172 if (now() >= deadline) break
173 try {
174 const receipt = await verifyPackage(pkg, {
175 registry,
176 fetchImpl,
177 requestTimeoutMs: Math.max(1, Math.min(30_000, deadline - now())),
178 })
179 verified.push(receipt)
180 pending.delete(id)
181 log(
182 `Verified ${id}: SHA512 and packed identity (${receipt.bytes} bytes)`,
183 )
184 } catch (error) {
185 if (!(error instanceof NotAvailable)) throw error
186 retryAfterMs = Math.max(retryAfterMs, error.retryAfterMs || 0)
187 lastReasons.push(`${id}: ${error.message}`)
188 }
189 }
190 if (!pending.size) return verified
191 const remaining = deadline - now()
192 if (remaining <= 0 || retryAfterMs > remaining) break
193 log(`Waiting for npm availability: ${lastReasons.join('; ')}`)
194 await sleep(retryAfterMs)
195 }
196 throw new Error(
197 `Release is not ready: ${[...pending.keys()].join(', ')}. ${lastReasons.join('; ')}. The version may still be scanned or staged. Rerun this verification job after availability changes, without rerunning the publisher.`,
198 )
199}
200
201if (
202 process.argv[1] &&
203 resolve(process.argv[1]) === fileURLToPath(import.meta.url)
204) {
205 try {
206 await verifyReleaseArtifacts(
207 JSON.parse(process.env.PUBLISHED_PACKAGES || 'null'),
208 )
209 } catch (error) {
210 console.error(error.message)
211 process.exitCode = 1
212 }
213}