shibosoftwaredev/f1c100s-linux-nema17-stepper-controller

scripts/verify-round3-publication.mjs

import fs from "node:fs"
import os from "node:os"
import path from "node:path"
import crypto from "node:crypto"
import assert from "node:assert/strict"

const manifest=JSON.parse(fs.readFileSync("reports/round3-publish-manifest.json","utf8"))
const nameWithVersion=`${manifest.packageName}@${manifest.version}`
const sha=bytes=>crypto.createHash("sha256").update(bytes).digest("hex")
async function request(endpoint,{body,authenticated=false}={}){
  const token=authenticated?(process.env.TSCIRCUIT_TOKEN??JSON.parse(fs.readFileSync(path.join(os.homedir(),"Library/Preferences/tscircuit-nodejs/config.json"),"utf8")).sessionToken):null
  const r=await fetch("https://registry-api.tscircuit.com/"+endpoint,{method:body?"POST":"GET",
    headers:{...(body?{"content-type":"application/json"}:{}),...(token?{authorization:`Bearer ${token}`}:{})},
    body:body?JSON.stringify(body):undefined,signal:AbortSignal.timeout(45000)})
  assert.ok(r.ok,`${endpoint.split("?")[0]} HTTP ${r.status}`);return r.json()
}
let release=(await request("package_releases/get",{body:{package_name_with_version:nameWithVersion}})).package_release
let pkg=(await request("packages/get",{body:{name:manifest.packageName}})).package
assert.ok([manifest.previous.latestReleaseId,release.package_release_id].includes(pkg.latest_package_release_id),"concurrent unrelated latest update")
const report={checkedAt:new Date().toISOString(),packageName:manifest.packageName,version:manifest.version,
  releaseId:release.package_release_id,url:`https://tscircuit.com/${manifest.packageName}?version=${manifest.version}#3d`,
  previousVersion:manifest.previous.latestVersion,previousReleaseId:manifest.previous.latestReleaseId,
  readyToBuild:release.ready_to_build,cloudBuildCompletedAt:release.user_code_job_completed_at,
  buildError:release.user_code_job_error??release.circuit_json_build_error,
  latestVersion:pkg.latest_version,latestVerified:pkg.latest_package_release_id===release.package_release_id,
  fabricationReady:false,auditedCircuitSha256:manifest.circuitSha256}
const inspectingSuccessfulBuild=process.argv.includes("--verified-build")
assert.ok(!report.buildError||(inspectingSuccessfulBuild&&report.buildError?.error_code==="user_code_job_infrastructure_error"),`Website build error: ${JSON.stringify(report.buildError).slice(0,400)}`)
const files=(await request("package_files/list?"+new URLSearchParams({package_release_id:release.package_release_id}))).package_files
report.files=files.length
const byPath=new Map(files.map(f=>[f.file_path,f]))
async function readFile(filename){
  const entry=byPath.get(filename);assert.ok(entry,`uploaded file exists: ${filename}`)
  const f=(await request("package_files/get?"+new URLSearchParams({package_file_id:entry.package_file_id}))).package_file
  if(f.is_text===false&&f.content_base64==null){
    const response=await fetch("https://registry-api.tscircuit.com/package_files/download?"+new URLSearchParams({package_file_id:entry.package_file_id}),{signal:AbortSignal.timeout(45000)})
    assert.ok(response.ok,`download binary ${filename}: HTTP ${response.status}`)
    return Buffer.from(await response.arrayBuffer())
  }
  return f.content_text!=null?Buffer.from(f.content_text):Buffer.from(f.content_base64??"","base64")
}
if(process.argv.includes("--verify-files")||process.argv.includes("--promote")){
  const pending=manifest.files.filter(f=>!f.file.startsWith("dist/")),checked=[]
  await Promise.all(Array.from({length:4},async()=>{
    while(pending.length){
      const file=pending.shift();assert.equal(sha(await readFile(file.file)),file.sha256,`exact source: ${file.file}`)
      checked.push(file.file)
    }
  }))
  report.sourceFilesVerified=checked.length
  release=(await request("package_releases/get",{body:{package_name_with_version:nameWithVersion}})).package_release
  report.cloudBuildCompletedAt=release.user_code_job_completed_at
  report.buildError=release.user_code_job_error??release.circuit_json_build_error
  assert.ok(!report.buildError||(inspectingSuccessfulBuild&&report.buildError?.error_code==="user_code_job_infrastructure_error"),`Website build error: ${JSON.stringify(report.buildError).slice(0,400)}`)
}
const buildIndex=process.argv.indexOf("--verified-build")
if(buildIndex>=0){
  const buildId=process.argv[buildIndex+1];assert.ok(buildId)
  const build=(await request("package_builds/get?"+new URLSearchParams({package_build_id:buildId}))).package_build
  assert.equal(build.package_release_id,release.package_release_id)
  assert.ok(build.user_code_job_completed_at&&!build.user_code_job_error&&!build.circuit_json_build_error&&!build.transpilation_error)
  report.verifiedSuccessfulBuildId=buildId
  report.cloudBuildCompletedAt=build.user_code_job_completed_at
  report.latestBuildId=release.latest_package_build_id
  if(release.latest_package_build_id!==buildId){
    const latestBuild=(await request("package_builds/get?"+new URLSearchParams({package_build_id:release.latest_package_build_id}))).package_build
    report.latestBuildError=latestBuild.user_code_job_error
    report.latestBuildFailed=true
  }
}
if(report.cloudBuildCompletedAt){
  const bytes=await readFile("dist/index/circuit.json"),remote=JSON.parse(bytes),local=JSON.parse(fs.readFileSync("dist/index/circuit.json","utf8"))
  assert.equal(sha(fs.readFileSync("dist/index/circuit.json")),manifest.circuitSha256)
  const types=new Set(["pcb_board","pcb_component","pcb_port","pcb_smtpad","pcb_plated_hole","pcb_hole","pcb_trace","pcb_via","pcb_copper_pour","pcb_keepout","source_component","source_port","source_trace","source_net","source_component_internal_connection"])
  const normalize=v=>JSON.stringify(v,(_,x)=>typeof x==="number"?Math.round(x*1e8)/1e8:x&&typeof x==="object"&&!Array.isArray(x)?Object.fromEntries(Object.entries(x).sort(([a],[b])=>a.localeCompare(b))):x)
  const critical=c=>c.filter(e=>types.has(e.type)||e.type.startsWith("schematic_")).map(normalize).sort()
  assert.deepEqual(critical(remote),critical(local),"website electrical, mechanical, copper and schematic records match audited artifact")
  assert.equal(remote.filter(e=>e.type.endsWith("_error")).length,0)
  assert.equal(remote.filter(e=>e.type.endsWith("_warning")).length,150)
  fs.writeFileSync("reports/round3-website-circuit.json",bytes)
  report.websiteCircuitSha256=sha(bytes);report.websiteMatchesAuditedRecords=true
  report.nativeErrors=0;report.nativeWarnings=150
  if(process.argv.includes("--promote")){
    assert.ok(!report.latestBuildFailed,"do not promote while the platform selects a failed latest build")
    assert.equal(report.sourceFilesVerified,manifest.files.filter(f=>!f.file.startsWith("dist/")).length)
    pkg=(await request("packages/get",{body:{name:manifest.packageName}})).package
    assert.ok([manifest.previous.latestReleaseId,release.package_release_id].includes(pkg.latest_package_release_id),"do not supersede a concurrent unrelated latest update")
    if(pkg.latest_package_release_id!==release.package_release_id)
      await request("package_releases/update",{body:{package_release_id:release.package_release_id,is_latest:true},authenticated:true})
    pkg=(await request("packages/get",{body:{name:manifest.packageName}})).package
    assert.equal(pkg.latest_package_release_id,release.package_release_id)
    const previous=(await request("package_releases/get",{body:{package_name_with_version:`${manifest.packageName}@${manifest.previous.latestVersion}`}})).package_release
    assert.equal(previous.package_release_id,manifest.previous.latestReleaseId)
    report.previousReleaseRetained=true;report.latestVerified=true;report.latestVersion=pkg.latest_version
  }
}
fs.writeFileSync("reports/round3-publication.json",JSON.stringify(report,null,2)+"\n")
console.log(JSON.stringify(report))
if(!report.websiteMatchesAuditedRecords)process.exitCode=2