@aepyornis/fastboot.ts 0.0.1 → 0.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aepyornis/fastboot.ts",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "fastboot again",
   "main": "src/index.ts",
   "scripts": {

package/src/client.ts

@@ -1,6 +1,6 @@
 import { BlobWriter, Entry } from "@zip.js/zip.js"
 import { IMAGES } from "./images"
-import { parseFileHeader, splitBlob, fromRaw } from "./sparse"
+import { parseBlobHeader, splitBlob, fromRaw } from "./sparse"
 import { FastbootDevice } from "./device"
 
 export class FastbootError extends Error {}
@@ -32,7 +32,6 @@ export class FastbootClient {
 
   async lock() {
     await this.flashing("lock")
-    await this.fd.waitForReconnect()
     if (await this.unlocked()) {
       throw new FastbootError("failed to lock device")
     }
@@ -40,7 +39,6 @@ export class FastbootClient {
 
   async unlock() {
     await this.flashing("unlock")
-    await this.fd.waitForReconnect()
     if (await this.locked()) {
       throw new FastbootError("failed to unlock device")
     }
@@ -147,14 +145,9 @@ export class FastbootClient {
     await this.fd.waitForReconnect()
   }
 
-  // run directions, typically the contents of fastboot-info.txt
-  // retriving the flashing data from files in entries
-  async fastbootInfo(
-    entries: Entry[],
-    directions: string,
-    wipe: boolean = false,
-  ) {
-    const lines = directions
+  // run text, typically the contents of fastboot-info.txt
+  async fastbootInfo(entries: Entry[], text: string, wipe: boolean = false) {
+    const lines = text
       .split("\n")
       .map((x) => x.trim())
       .filter((l) => !(l == "" || l[0] == "#" || l.slice(0, 7) == "version"))
@@ -318,27 +311,3 @@ export class FastbootClient {
     })
   }
 }
-
-async function parseBlobHeader(blob: Blob): {
-  blobSize: number
-  totalBytes: number
-  isSparse: boolean
-} {
-  const FILE_HEADER_SIZE = 28
-  const blobSize = blob.size
-  let totalBytes = blobSize
-  let isSparse = false
-
-  try {
-    const fileHeader = await blob.slice(0, FILE_HEADER_SIZE).arrayBuffer()
-    const sparseHeader = parseFileHeader(fileHeader)
-    if (sparseHeader !== null) {
-      totalBytes = sparseHeader.blocks * sparseHeader.blockSize
-      isSparse = true
-    }
-  } catch (error) {
-    console.debug(error)
-    // ImageError = invalid, so keep blob.size
-  }
-  return { blobSize, totalBytes, isSparse }
-}

package/src/device.ts

@@ -101,7 +101,10 @@ export class FastbootDevice {
     return new Promise((resolve, reject) => {
       navigator.usb.addEventListener(
         "connect",
-        async () => {
+        async (event) => {
+          this.logger.log(
+            `waitForReconnect: device connected ${event.device.productName}`,
+          )
           try {
             await this.reconnect()
             resolve(true)

package/src/flasher.ts

@@ -57,8 +57,8 @@ function parseInstruction(text: string): Instruction {
         options.wipe = true
       } else if (word === "--set-active=other") {
         options.setActive = "other"
-      } else if (word === '--slot-other') {
-	options.slot = 'other'
+      } else if (word === "--slot-other") {
+        options.slot = "other"
       } else if (word.slice(0, 6) === "--slot") {
         const slot = word.split("=")[1]
         if (!["current", "other", "a", "b"].includes(slot)) {

package/src/sparse.ts

@@ -1,6 +1,7 @@
 // The MIT License (MIT)
 
 // Copyright (c) 2021 Danny Lin <danny@kdrag0n.dev>
+// Copyright (c) 2025 ziggy <ziggy@calyxinstitute.org>
 
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -20,26 +21,6 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-function readBlobAsBuffer(blob: Blob): Promise<ArrayBuffer> {
-  return new Promise((resolve, reject) => {
-    let reader = new FileReader()
-    reader.onload = () => {
-      resolve(reader.result! as ArrayBuffer)
-    }
-    reader.onerror = () => {
-      reject(reader.error)
-    }
-
-    reader.readAsArrayBuffer(blob)
-  })
-}
-
-const common = {
-  readBlobAsBuffer: readBlobAsBuffer,
-  logVerbose: (...data) => console.log(...data),
-  logDebug: (...data) => console.log(...data),
-}
-
 const FILE_MAGIC = 0xed26ff3a
 
 const MAJOR_VERSION = 1
@@ -109,29 +90,29 @@ class BlobBuilder {
  * @returns {SparseHeader} Object containing the header information.
  */
 export function parseFileHeader(buffer: ArrayBuffer): SparseHeader | null {
-  let view = new DataView(buffer)
+  const view = new DataView(buffer)
 
-  let magic = view.getUint32(0, true)
+  const magic = view.getUint32(0, true)
   if (magic !== FILE_MAGIC) {
     return null
   }
 
   // v1.0+
-  let major = view.getUint16(4, true)
-  let minor = view.getUint16(6, true)
+  const major = view.getUint16(4, true)
+  const minor = view.getUint16(6, true)
   if (major !== MAJOR_VERSION || minor < MINOR_VERSION) {
     throw new ImageError(`Unsupported sparse image version ${major}.${minor}`)
   }
 
-  let fileHdrSize = view.getUint16(8, true)
-  let chunkHdrSize = view.getUint16(10, true)
+  const fileHdrSize = view.getUint16(8, true)
+  const chunkHdrSize = view.getUint16(10, true)
   if (fileHdrSize !== FILE_HEADER_SIZE || chunkHdrSize !== CHUNK_HEADER_SIZE) {
     throw new ImageError(
       `Invalid file header size ${fileHdrSize}, chunk header size ${chunkHdrSize}`,
     )
   }
 
-  let blockSize = view.getUint32(12, true)
+  const blockSize = view.getUint32(12, true)
   if (blockSize % 4 !== 0) {
     throw new ImageError(`Block size ${blockSize} is not a multiple of 4`)
   }
@@ -144,8 +125,8 @@ export function parseFileHeader(buffer: ArrayBuffer): SparseHeader | null {
   }
 }
 
-function parseChunkHeader(buffer: ArrayBuffer) {
-  let view = new DataView(buffer)
+function parseChunkHeader(buffer: ArrayBuffer): SparseChunk {
+  const view = new DataView(buffer)
 
   // This isn't the same as what createImage takes.
   // Further processing needs to be done on the chunks.
@@ -155,7 +136,7 @@ function parseChunkHeader(buffer: ArrayBuffer) {
     blocks: view.getUint32(4, true),
     dataBytes: view.getUint32(8, true) - CHUNK_HEADER_SIZE,
     data: null, // to be populated by consumer
-  } as SparseChunk
+  }
 }
 
 function calcChunksBlockSize(chunks: Array<SparseChunk>) {
@@ -170,7 +151,7 @@ function calcChunksDataSize(chunks: Array<SparseChunk>) {
 
 function calcChunksSize(chunks: Array<SparseChunk>) {
   // 28-byte file header, 12-byte chunk headers
-  let overhead = FILE_HEADER_SIZE + CHUNK_HEADER_SIZE * chunks.length
+  const overhead = FILE_HEADER_SIZE + CHUNK_HEADER_SIZE * chunks.length
   return overhead + calcChunksDataSize(chunks)
 }
 
@@ -178,7 +159,7 @@ async function createImage(
   header: SparseHeader,
   chunks: Array<SparseChunk>,
 ): Promise<Blob> {
-  let blobBuilder = new BlobBuilder()
+  const blobBuilder = new BlobBuilder()
 
   let buffer = new ArrayBuffer(FILE_HEADER_SIZE)
   let dataView = new DataView(buffer)
@@ -202,7 +183,7 @@ async function createImage(
   dataView.setUint32(24, 0, true)
 
   blobBuilder.append(new Blob([buffer]))
-  for (let chunk of chunks) {
+  for (const chunk of chunks) {
     buffer = new ArrayBuffer(CHUNK_HEADER_SIZE + chunk.data!.size)
     dataView = new DataView(buffer)
     arrayView = new Uint8Array(buffer)
@@ -212,9 +193,7 @@ async function createImage(
     dataView.setUint32(4, chunk.blocks, true)
     dataView.setUint32(8, CHUNK_HEADER_SIZE + chunk.data!.size, true)
 
-    let chunkArrayView = new Uint8Array(
-      await common.readBlobAsBuffer(chunk.data!),
-    )
+    const chunkArrayView = new Uint8Array(await chunk.data!.arrayBuffer())
     arrayView.set(chunkArrayView, CHUNK_HEADER_SIZE)
     blobBuilder.append(new Blob([buffer]))
   }
@@ -229,21 +208,21 @@ async function createImage(
  * @returns {Promise<Blob>} Promise that resolves the blob containing the new sparse image.
  */
 export async function fromRaw(blob: Blob): Promise<Blob> {
-  let header = {
+  const header = {
     blockSize: 4096,
     blocks: blob.size / 4096,
     chunks: 1,
     crc32: 0,
   }
 
-  let chunks = []
+  const chunks: SparseChunk[] = []
   while (blob.size > 0) {
-    let chunkSize = Math.min(blob.size, RAW_CHUNK_SIZE)
+    const chunkSize = Math.min(blob.size, RAW_CHUNK_SIZE)
     chunks.push({
       type: ChunkType.Raw,
       blocks: chunkSize / header.blockSize,
       data: blob.slice(0, chunkSize),
-    } as SparseChunk)
+    })
     blob = blob.slice(chunkSize)
   }
 
@@ -260,7 +239,7 @@ export async function fromRaw(blob: Blob): Promise<Blob> {
  * @yields {Object} Data of the next split image and its output size in bytes.
  */
 export async function* splitBlob(blob: Blob, splitSize: number) {
-  common.logDebug(
+  console.debug(
     `Splitting ${blob.size}-byte sparse image into ${splitSize}-byte chunks`,
   )
 
@@ -270,18 +249,17 @@ export async function* splitBlob(blob: Blob, splitSize: number) {
 
   // Short-circuit if splitting isn't required
   if (blob.size <= splitSize) {
-    common.logDebug("Blob fits in 1 payload, not splitting")
+    console.debug("Blob fits in 1 payload, not splitting")
     yield {
-      data: await common.readBlobAsBuffer(blob),
+      data: await blob.arrayBuffer(),
       bytes: blob.size,
     } as SparseSplit
     return
   }
 
-  let headerData = await common.readBlobAsBuffer(
-    blob.slice(0, FILE_HEADER_SIZE),
-  )
-  let header = parseFileHeader(headerData)
+  const headerData = await blob.slice(0, FILE_HEADER_SIZE).arrayBuffer()
+
+  const header = parseFileHeader(headerData)
   if (header === null) {
     throw new ImageError("Blob is not a sparse image")
   }
@@ -293,21 +271,19 @@ export async function* splitBlob(blob: Blob, splitSize: number) {
   let splitChunks: Array<SparseChunk> = []
   let splitDataBytes = 0
   for (let i = 0; i < header.chunks; i++) {
-    let chunkHeaderData = await common.readBlobAsBuffer(
-      blob.slice(0, CHUNK_HEADER_SIZE),
-    )
-    let originalChunk = parseChunkHeader(chunkHeaderData)
+    const chunkHeaderData = await blob.slice(0, CHUNK_HEADER_SIZE).arrayBuffer()
+    const originalChunk = parseChunkHeader(chunkHeaderData)
     originalChunk.data = blob.slice(
       CHUNK_HEADER_SIZE,
       CHUNK_HEADER_SIZE + originalChunk.dataBytes,
     )
     blob = blob.slice(CHUNK_HEADER_SIZE + originalChunk.dataBytes)
 
-    let chunksToProcess: SparseChunk[] = []
+    const chunksToProcess: SparseChunk[] = []
 
     // take into account cases where the chunk data is bigger than the maximum allowed download size
     if (originalChunk.dataBytes > safeSendValue) {
-      common.logDebug(
+      console.debug(
         `Data of chunk ${i} is bigger than the maximum allowed download size: ${originalChunk.dataBytes} > ${safeSendValue}`,
       )
 
@@ -329,20 +305,20 @@ export async function* splitBlob(blob: Blob, splitSize: number) {
         originalDataBytes -= toSend
       }
 
-      common.logDebug("chunksToProcess", chunksToProcess)
+      console.debug("chunksToProcess", chunksToProcess)
     } else {
       chunksToProcess.push(originalChunk)
     }
 
     for (const chunk of chunksToProcess) {
-      let bytesRemaining = splitSize - calcChunksSize(splitChunks)
-      common.logVerbose(
+      const bytesRemaining = splitSize - calcChunksSize(splitChunks)
+      console.debug(
         `  Chunk ${i}: type ${chunk.type}, ${chunk.dataBytes} bytes / ${chunk.blocks} blocks, ${bytesRemaining} bytes remaining`,
       )
 
       if (bytesRemaining >= chunk.dataBytes) {
         // Read the chunk and add it
-        common.logVerbose("    Space is available, adding chunk")
+        console.debug("    Space is available, adding chunk")
         splitChunks.push(chunk)
         // Track amount of data written on the output device, in bytes
         splitDataBytes += chunk.blocks * header.blockSize
@@ -350,30 +326,30 @@ export async function* splitBlob(blob: Blob, splitSize: number) {
         // Out of space, finish this split
         // Blocks need to be calculated from chunk headers instead of going by size
         // because FILL and SKIP chunks cover more blocks than the data they contain.
-        let splitBlocks = calcChunksBlockSize(splitChunks)
+        const splitBlocks = calcChunksBlockSize(splitChunks)
         splitChunks.push({
           type: ChunkType.Skip,
           blocks: header.blocks - splitBlocks,
           data: new Blob([]),
           dataBytes: 0,
         })
-        common.logVerbose(
+        console.debug(
           `Partition is ${header.blocks} blocks, used ${splitBlocks}, padded with ${
             header.blocks - splitBlocks
           }, finishing split with ${calcChunksBlockSize(splitChunks)} blocks`,
         )
-        let splitImage = await createImage(header, splitChunks)
-        common.logDebug(
+        const splitImage = await createImage(header, splitChunks)
+        console.debug(
           `Finished ${splitImage.size}-byte split with ${splitChunks.length} chunks`,
         )
         yield {
-          data: await common.readBlobAsBuffer(splitImage),
+          data: await splitImage.arrayBuffer(),
           bytes: splitDataBytes,
         } as SparseSplit
 
         // Start a new split. Every split is considered a full image by the
         // bootloader, so we need to skip the *total* written blocks.
-        common.logVerbose(
+        console.debug(
           `Starting new split: skipping first ${splitBlocks} blocks and adding chunk`,
         )
         splitChunks = [
@@ -396,13 +372,37 @@ export async function* splitBlob(blob: Blob, splitSize: number) {
     splitChunks.length > 0 &&
     (splitChunks.length > 1 || splitChunks[0].type !== ChunkType.Skip)
   ) {
-    let splitImage = await createImage(header, splitChunks)
-    common.logDebug(
+    const splitImage = await createImage(header, splitChunks)
+    console.debug(
       `Finishing final ${splitImage.size}-byte split with ${splitChunks.length} chunks`,
     )
     yield {
-      data: await common.readBlobAsBuffer(splitImage),
+      data: await splitImage.arrayBuffer(),
       bytes: splitDataBytes,
     } as SparseSplit
   }
 }
+
+export async function parseBlobHeader(blob: Blob): {
+  blobSize: number
+  totalBytes: number
+  isSparse: boolean
+} {
+  const FILE_HEADER_SIZE = 28
+  const blobSize = blob.size
+  let totalBytes = blobSize
+  let isSparse = false
+
+  try {
+    const fileHeader = await blob.slice(0, FILE_HEADER_SIZE).arrayBuffer()
+    const sparseHeader = parseFileHeader(fileHeader)
+    if (sparseHeader !== null) {
+      totalBytes = sparseHeader.blocks * sparseHeader.blockSize
+      isSparse = true
+    }
+  } catch (error) {
+    console.debug(error)
+    // ImageError = invalid, so keep blob.size
+  }
+  return { blobSize, totalBytes, isSparse }
+}