From d068f164d30d9752ee20a1ecba8a44ef6e147376 Mon Sep 17 00:00:00 2001 From: morluto <76467478+morluto@users.noreply.github.com> Date: Mon, 16 Nov 2026 04:38:58 +0800 Subject: [PATCH] refactor(domain): move the lipo detailed-info parser into src/domain/apple (#11460) --- scripts/lib/module-layers.baseline.json | 2 +- src/artifacts/MachOSliceArtifactReader.ts | 16 +- src/domain/apple/lipo.test.ts | 382 +++++++++++++++++ src/domain/apple/lipo.ts | 373 +++++++++++++++++ src/domain/native/nativeCommandOutput.ts | 2 + src/native/CommandRunner.ts | 3 +- src/native/MachoArchitectureSelection.test.ts | 2 +- src/native/MachoArchitectureSelection.ts | 2 +- src/native/NativeCommandAnalysisError.ts | 2 +- src/native/NativeMacOSProvider.ts | 2 +- src/native/NativeMachoInspection.ts | 9 +- src/native/NativeMachoSelectedSlice.test.ts | 2 +- src/native/NativeMachoSelectedSlice.ts | 2 +- src/native/parsers/lipo.test.ts | 382 +---------------- src/native/parsers/lipo.ts | 385 +----------------- .../native/lipoFieldOwnership.test.ts | 8 +- .../providers/native/nativeProvider.test.ts | 2 +- .../native/nativeTextRobustness.test.ts | 2 +- tests/fixtures/lipo.ts | 2 +- 19 files changed, 790 insertions(+), 790 deletions(-) create mode 100644 src/domain/apple/lipo.test.ts create mode 100644 src/domain/apple/lipo.ts create mode 100644 src/domain/native/nativeCommandOutput.ts diff --git a/scripts/lib/module-layers.baseline.json b/scripts/lib/module-layers.baseline.json index 233bc24180..6e653c9b5b 100644 --- a/scripts/lib/module-layers.baseline.json +++ b/scripts/lib/module-layers.baseline.json @@ -22,7 +22,7 @@ "apktool -> artifacts": 2, "artifacts -> dotnet": 3, "artifacts -> javascript": 1, - "artifacts -> native": 2, + "artifacts -> native": 1, "browser -> artifacts": 6, "browser -> electron": 5, "browser -> javascript": 1, diff --git a/src/artifacts/MachOSliceArtifactReader.ts b/src/artifacts/MachOSliceArtifactReader.ts index d19835a4c7..e26683494d 100644 --- a/src/artifacts/MachOSliceArtifactReader.ts +++ b/src/artifacts/MachOSliceArtifactReader.ts @@ -7,6 +7,8 @@ import { type ArtifactReader, type ArtifactReaderTraversal, type ArtifactTraversalOptions, + streamChunkToBuffer, + readArtifactFileChunks, } from "../resources/index.js"; import type { FileHandle } from "node:fs/promises"; import { Readable } from "node:stream"; @@ -16,11 +18,6 @@ import { XcrunCommandRunner, type NativeCommandRunner, } from "../native/CommandRunner.js"; -import { - parseLipoOutputResult, - LipoFieldRetentionError, - type LipoArchitecture, -} from "../native/parsers/lipo.js"; import type { MachoSlice } from "../domain/apple/dylibResolution.js"; import { machoArchitectureFamily, @@ -31,14 +28,15 @@ import { readMachoImage, type ReadAt, } from "../domain/apple/machoLoadCommandReader.js"; -import { - streamChunkToBuffer, - readArtifactFileChunks, -} from "../resources/index.js"; import type { StableRegularFileDescriptor } from "../filesystem/RegularFile.js"; import { ArtifactFileSource } from "./ArtifactFileSource.js"; import { readFileHandleRange } from "../filesystem/readFileHandleRange.js"; import type { ArtifactIntegrityPolicyName } from "../domain/artifactIntegrityPolicy.js"; +import { + parseLipoOutputResult, + LipoFieldRetentionError, + type LipoArchitecture, +} from "../domain/apple/lipo.js"; /** Read-only universal Mach-O slice reader backed by native lipo metadata. */ export class MachOSliceArtifactReader implements ArtifactReader { diff --git a/src/domain/apple/lipo.test.ts b/src/domain/apple/lipo.test.ts new file mode 100644 index 0000000000..e1e8367e76 --- /dev/null +++ b/src/domain/apple/lipo.test.ts @@ -0,0 +1,382 @@ +import { describe, expect, it } from "vitest"; + +import { parseLipoFixture } from "../../../tests/fixtures/lipo.js"; + +const fatRecords = `fat_magic 0xcafebabe +nfat_arch 2 +architecture arm64 + cputype CPU_TYPE_ARM64 + cpusubtype CPU_SUBTYPE_ARM64_ALL + capabilities 0x0 + offset 4096 + size 32 + align 2^12 (4096) +architecture x86_64 + cputype CPU_TYPE_X86_64 + cpusubtype CPU_SUBTYPE_X86_64_ALL + capabilities 0x0 + offset 8192 + size 32 + align 2^12 (4096) +`; + +describe("lipo numeric field observations", () => { + it.each([ + { field: "offset", source: "-1" }, + { field: "size", source: "9007199254740992" }, + { field: "align", source: "2^12 (2048)" }, + { field: "align", source: "2^53" }, + { field: "offset", source: "" }, + ] as const)( + "retains an explicit uninterpretable $field source: $source", + ({ field, source }) => { + const sourceLine = `\t${field} ${source} `; + const architecture = parseLipoFixture( + `architecture arm64\n cputype 16777228\n${sourceLine}\n`, + ).architectures[0]; + expect(architecture?.cpu_type_code).toBe(16777228); + expect(architecture?.fields[field]).toEqual({ + kind: "uninterpretable", + sourceLines: [sourceLine], + }); + expect(architecture?.limitations).toHaveLength(1); + expect(architecture?.limitations[0]).toContain(sourceLine); + expect(architecture?.limitations[0]).toContain(field); + expect(architecture?.limitations[0]).toMatch( + /lipo.*arm64.*could not be interpreted/iu, + ); + }, + ); + + it("parses each valid numeric field once while preserving its exact source line", () => { + const architecture = parseLipoFixture( + "architecture arm64\n offset 4096 \n size 48\n align 2^12 (4096)\n", + ).architectures[0]; + expect(architecture).toMatchObject({ + file_offset: 4096, + size: 48, + alignment: 4096, + limitations: [], + fields: { + offset: { + kind: "parsed", + sourceLines: [" offset 4096 "], + value: 4096, + }, + size: { kind: "parsed", sourceLines: [" size 48"], value: 48 }, + align: { + kind: "parsed", + sourceLines: [" align 2^12 (4096)"], + value: 4096, + }, + }, + }); + }); + + it.each(["offset", "size", "align"] as const)( + "retains every repeated %s declaration and requires their parsed values to agree", + (field) => { + const first = field === "align" ? "2^12 (4096)" : "4096"; + const conflicting = field === "align" ? "2^13 (8192)" : "8192"; + for (const second of [first, conflicting, "unsupported"]) { + const sourceLines = [` ${field} ${first}`, `\t${field} ${second} `]; + const row = parseLipoFixture( + `architecture arm64\n${sourceLines.join("\n")}\n`, + ).architectures[0]; + expect(row?.fields[field]).toEqual( + second === first + ? { kind: "parsed", sourceLines, value: 4096 } + : { kind: "uninterpretable", sourceLines }, + ); + if (second === first) expect(row?.limitations).toEqual([]); + else { + expect(row?.limitations).toHaveLength(1); + for (const line of sourceLines) + expect(row?.limitations[0]).toContain(line); + } + } + }, + ); +}); + +it.each([ + { + type: "constructor", + subtype: "CPU_SUBTYPE_ARM64_ALL", + typeCode: null, + subtypeCode: 0, + subtypeBase: 0, + }, + { + type: "CPU_TYPE_ARM64", + subtype: "toString", + typeCode: 0x0100000c, + subtypeCode: null, + subtypeBase: null, + }, +])( + "preserves unknown CPU names without inventing codes", + ({ type, subtype, typeCode, subtypeCode, subtypeBase }) => { + const { architectures } = parseLipoFixture( + fatRecords + .replace("CPU_TYPE_ARM64", type) + .replace("CPU_SUBTYPE_ARM64_ALL", subtype), + ); + expect(architectures[0]).toMatchObject({ + cpu_type: type, + cpu_type_code: typeCode, + cpu_subtype: subtype, + cpu_subtype_code: subtypeCode, + cpu_subtype_base: subtypeBase, + }); + }, +); + +describe("lipo architecture facts", () => { + it("preserves Apple's declared and hidden ARM64 architecture scopes", () => { + const output = parseLipoFixture(`fat_magic 0xcafebabe +nfat_arch 1 (+1 hidden) +architecture armv7 + cputype CPU_TYPE_ARM + cpusubtype CPU_SUBTYPE_ARM_V7 + offset 4096 + size 28 + align 2^12 (4096) +architecture arm64 (hidden) + cputype CPU_TYPE_ARM64 + cpusubtype CPU_SUBTYPE_ARM64_ALL + offset 8192 + size 32 + align 2^12 (4096) +`); + expect(output).toMatchObject({ + declaredArchitectureCount: 1, + hiddenArchitectureCount: 1, + architectures: [ + { name: "armv7", hidden: false }, + { name: "arm64", hidden: true, file_offset: 8192, size: 32 }, + ], + }); + }); + + it("normalizes symbolic CPU fields and arm64e capability bits", () => { + const { format, architectures } = parseLipoFixture(`Fat header in: /bin/ls +fat_magic 0xcafebabe +nfat_arch 2 +architecture x86_64 + cputype CPU_TYPE_X86_64 + cpusubtype CPU_SUBTYPE_X86_64_ALL + capabilities 0x0 + offset 16384 + size 48112 + align 2^14 (16384) +architecture arm64e + cputype CPU_TYPE_ARM64 + cpusubtype CPU_SUBTYPE_ARM64E + capabilities PTR_AUTH_VERSION USERSPACE 0 + offset 65536 + size 89088 + align 2^14 (16384) +`); + expect(format).toBe("fat"); + expect(architectures).toEqual([ + expect.objectContaining({ + name: "x86_64", + cpu_type: "CPU_TYPE_X86_64", + cpu_type_code: 0x01000007, + cpu_subtype: "CPU_SUBTYPE_X86_64_ALL", + cpu_subtype_code: 3, + capabilities: "0x0", + file_offset: 16384, + size: 48112, + alignment: 16384, + }), + expect.objectContaining({ + name: "arm64e", + cpu_type: "CPU_TYPE_ARM64", + cpu_type_code: 0x0100000c, + cpu_subtype: "CPU_SUBTYPE_ARM64E", + cpu_subtype_code: 0x80000002, + capabilities: "PTR_AUTH_VERSION USERSPACE 0", + file_offset: 65536, + size: 89088, + alignment: 16384, + }), + ]); + }); + + it("normalizes the CPU names lipo prints for i386 slices", () => { + // cctools misc/lipo.c print_cputype() spells i386 with I386 names. + expect( + parseLipoFixture(`architecture i386 + cputype CPU_TYPE_I386 + cpusubtype CPU_SUBTYPE_I386_ALL + capabilities 0x0 + offset 16384 + size 28 + align 2^14 (16384) +`).architectures, + ).toMatchObject([ + { + name: "i386", + cpu_type_code: 7, + cpu_subtype_code: 3, + cpu_subtype_base: 3, + }, + ]); + }); + + it("keeps unknown symbolic CPU values as source text without a code", () => { + expect( + parseLipoFixture( + "architecture future\n cputype CPU_TYPE_FUTURE\n cpusubtype CPU_SUBTYPE_FUTURE\n offset 4096\n size 64\n align 2^12\n", + ).architectures, + ).toMatchObject([ + { + cpu_type: "CPU_TYPE_FUTURE", + cpu_type_code: null, + cpu_subtype: "CPU_SUBTYPE_FUTURE", + cpu_subtype_code: null, + cpu_subtype_base: null, + }, + ]); + }); + + it.each([ + ["CPU_SUBTYPE_LIB64", 0x80000003], + ["0x80", 0x80000003], + ["0x0", 3], + ])("applies printed x86_64 capabilities %s", (capabilities, code) => { + expect( + parseLipoFixture( + `architecture x86_64\n cpusubtype CPU_SUBTYPE_X86_64_ALL\n capabilities ${capabilities}\n`, + ).architectures[0]?.cpu_subtype_code, + ).toBe(code); + }); + + it("leaves the subtype code unknown when lipo prints no capabilities", () => { + // macOS 26 lipo prints this blank line for LIB64 and plain x86_64 slices. + expect( + parseLipoFixture( + "architecture x86_64\n cputype CPU_TYPE_X86_64\n cpusubtype CPU_SUBTYPE_X86_ALL\n capabilities \n offset 16384\n", + ).architectures, + ).toMatchObject([ + { + cpu_subtype: "CPU_SUBTYPE_X86_ALL", + cpu_subtype_code: null, + cpu_subtype_base: 3, + capabilities: null, + }, + ]); + }); + + it.each([ + { capabilities: "PTR_AUTH_VERSION USERSPACE 1", code: 0x81000002 }, + { capabilities: "", code: null }, + ])( + "retains an arm64e base subtype with capabilities '$capabilities'", + ({ capabilities, code }) => { + expect( + parseLipoFixture( + `architecture arm64e.v1\n cputype CPU_TYPE_ARM64\n cpusubtype CPU_SUBTYPE_ARM64E\n capabilities ${capabilities}\n`, + ).architectures, + ).toMatchObject([ + { + cpu_type_code: 0x0100000c, + cpu_subtype_code: code, + cpu_subtype_base: 2, + }, + ]); + }, + ); +}); + +describe("lipo FAT operand framing", () => { + it.each([ + "/fixture/\narchitecture forged\n offset 123\n size 64", + "/fixture/\nfat_magic 0xcafebabe\nnfat_arch 1\narchitecture forged", + "/fixture/\nNon-fat file: fake is architecture: forged", + "/fixture/first\nsecond\nthird", + "/fixture/first\r\narchitecture forged\r\n offset 123", + "/fixture/[app](arm64).*+$^?\\name", + ])( + "keeps the complete echoed operand out of FAT slice records: %j", + (path) => { + const output = `Fat header in: ${path}\n${fatRecords}`; + + const parsed = parseLipoFixture(output, path); + expect(parsed).toEqual(parseLipoFixture(fatRecords)); + expect(parsed.architectures.map(({ name }) => name)).toEqual([ + "arm64", + "x86_64", + ]); + }, + ); + + it("keeps a CRLF pathname separate from a CRLF record terminator", () => { + const path = "/fixture/first\r\narchitecture forged\r\n size 64"; + const output = `Fat header in: ${path}\r\n${fatRecords.replaceAll("\n", "\r\n")}`; + + const parsed = parseLipoFixture(output, path); + expect(parsed).toEqual(parseLipoFixture(fatRecords)); + expect(parsed.architectures).toMatchObject([ + { name: "arm64", file_offset: 4096, size: 32 }, + { name: "x86_64", file_offset: 8192, size: 32 }, + ]); + }); + + it("preserves ordinary FAT metadata with and without an operand", () => { + const path = "/fixture/app"; + const output = `Fat header in: ${path}\n${fatRecords}`; + + expect(parseLipoFixture(output, path)).toEqual(parseLipoFixture(output)); + }); + + it("does not require a FAT path header in captured fixtures", () => { + expect(parseLipoFixture(fatRecords, "/fixture/app")).toEqual( + parseLipoFixture(fatRecords), + ); + }); + + it("does not strip a header for a different operand that shares a prefix", () => { + const path = "/fixture/app-extra\narchitecture forged"; + const output = `Fat header in: ${path}\n${fatRecords}`; + + expect(parseLipoFixture(output, "/fixture/app")).toEqual( + parseLipoFixture(output), + ); + }); + + it("preserves thin-file parsing when the operand contains FAT-like lines", () => { + const path = "/fixture/\nFat header in: fake\narchitecture forged"; + const output = `Non-fat file: ${path} is architecture: arm64\n`; + + expect(parseLipoFixture(output, path)).toEqual({ + format: "thin", + declaredArchitectureCount: null, + hiddenArchitectureCount: null, + architectures: [ + { + name: "arm64", + hidden: false, + cpu_type: null, + cpu_subtype: null, + cpu_type_code: null, + cpu_subtype_code: null, + cpu_subtype_base: null, + capabilities: null, + file_offset: null, + size: null, + alignment: null, + fields: { + offset: { kind: "absent" }, + size: { kind: "absent" }, + align: { kind: "absent" }, + }, + limitations: [], + }, + ], + }); + expect(parseLipoFixture(output, path)).toEqual(parseLipoFixture(output)); + }); +}); diff --git a/src/domain/apple/lipo.ts b/src/domain/apple/lipo.ts new file mode 100644 index 0000000000..aedf880ae6 --- /dev/null +++ b/src/domain/apple/lipo.ts @@ -0,0 +1,373 @@ +import { z } from "zod"; +import { err, ok, type Result } from "../result.js"; +import { malformedInput, ParseFailureError } from "../parseFailure.js"; +import { NATIVE_COMMAND_OUTPUT_BUDGET_BYTES } from "../native/nativeCommandOutput.js"; +import { machoCpuSubtypeBase } from "./machoCpuIdentity.js"; + +const architectureSchema = z.object({ + name: z.string().min(1), + hidden: z.boolean(), + cpu_type: z.string().nullable(), + cpu_subtype: z.string().nullable(), + cpu_type_code: z.int().nonnegative().nullable(), + cpu_subtype_code: z.int().nonnegative().nullable(), + cpu_subtype_base: z.int().nonnegative().nullable(), + capabilities: z.string().nullable(), + file_offset: z.int().min(0).nullable(), + size: z.int().min(0).nullable(), + alignment: z.int().min(0).nullable(), +}); + +export type LipoFieldObservation = + | { readonly kind: "absent" } + | { + readonly kind: "parsed"; + readonly sourceLines: readonly string[]; + readonly value: number; + } + | { + readonly kind: "uninterpretable"; + readonly sourceLines: readonly string[]; + }; + +export type LipoArchitecture = z.infer & { + readonly fields: Readonly< + Record<"offset" | "size" | "align", LipoFieldObservation> + >; + readonly limitations: readonly string[]; +}; + +/** Capacity refusal before retaining expanded per-declaration source facts. */ +export class LipoFieldRetentionError extends Error { + readonly _tag = "LipoFieldRetentionError"; + constructor(readonly requiredBytes: number) { + super( + "lipo numeric field observations exceed the retained native output budget", + ); + this.name = this._tag; + } +} + +export interface LipoOutput { + readonly format: "thin" | "fat"; + /** `nfat_arch` counts visible rows; Apple may append one hidden ARM64 row. */ + readonly declaredArchitectureCount: number | null; + readonly hiddenArchitectureCount: number | null; + readonly architectures: LipoArchitecture[]; +} + +/** Parse `lipo -detailed_info` framing and deterministic slice metadata. */ +const parseLipoOutput = (output: string, operandPath?: string): LipoOutput => { + // The echoed FAT operand is one value, even when its pathname contains lines. + if (operandPath !== undefined) { + const header = `Fat header in: ${operandPath}`; + if (output.startsWith(header)) { + if (output.startsWith("\r\n", header.length)) + output = output.slice(header.length + 2); + else if (output.startsWith("\n", header.length)) + output = output.slice(header.length + 1); + } + } + // lipo echoes a thin file's pathname verbatim, including embedded newlines. + // Match its final architecture field before splitting records into lines. + const thinArchitecture = + /(?:^|\r?\n)Non-fat file:[\s\S]* is architecture: ([^\s]+)\s*$/u.exec( + output, + )?.[1]; + if (thinArchitecture !== undefined) + return { + format: "thin", + declaredArchitectureCount: null, + hiddenArchitectureCount: null, + architectures: [ + { + ...architectureSchema.parse({ + name: thinArchitecture, + hidden: false, + cpu_type: null, + cpu_subtype: null, + cpu_type_code: null, + cpu_subtype_code: null, + cpu_subtype_base: null, + capabilities: null, + file_offset: null, + size: null, + alignment: null, + }), + fields: { + offset: { kind: "absent" }, + size: { kind: "absent" }, + align: { kind: "absent" }, + }, + limitations: [], + }, + ], + }; + const architectures: LipoArchitecture[] = []; + let declaredArchitectureCount: number | null = null; + let hiddenArchitectureCount: number | null = null; + let current: Record | undefined; + let observations: Partial< + Record< + "offset" | "size" | "align", + { readonly sourceLine: string; readonly value: number | null }[] + > + > = {}; + let retainedFieldBytes = 0; + const admitFieldBytes = (bytes: number): void => { + retainedFieldBytes += bytes; + if (retainedFieldBytes > NATIVE_COMMAND_OUTPUT_BUDGET_BYTES) + throw new LipoFieldRetentionError(retainedFieldBytes); + }; + const flush = (): void => { + if (current === undefined) return; + const name = current.architecture ?? current["Non-fat file"]; + if (name !== undefined) { + const observe = ( + key: "offset" | "size" | "align", + ): LipoFieldObservation => { + const observed = observations[key]; + if (observed === undefined) return { kind: "absent" }; + const sourceLines = observed.map(({ sourceLine }) => sourceLine); + const value = observed[0]?.value; + return value === null || + value === undefined || + observed.some((candidate) => candidate.value !== value) + ? { kind: "uninterpretable", sourceLines } + : { kind: "parsed", sourceLines, value }; + }; + const fields = { + offset: observe("offset"), + size: observe("size"), + align: observe("align"), + }; + const value = (field: LipoFieldObservation): number | null => + field.kind === "parsed" ? field.value : null; + const limitations = Object.entries(fields).flatMap( + ([field, observation]) => { + if (observation.kind !== "uninterpretable") return []; + admitFieldBytes(name.length * 14 + 256); + return [ + `lipo ${field} for ${name} could not be interpreted; ${observation.sourceLines.length === 1 ? "source line: " : "source lines:\n"}${observation.sourceLines.join("\n")}`, + ]; + }, + ); + architectures.push({ + ...architectureSchema.parse({ + name: name.includes(" is architecture: ") + ? (name.split(" is architecture: ").at(-1) ?? name) + : name.replace(/ \(hidden\)$/u, ""), + hidden: name.endsWith(" (hidden)"), + cpu_type: current.cputype ?? null, + cpu_subtype: current.cpusubtype ?? null, + cpu_type_code: cpuTypeCode(current.cputype), + cpu_subtype_code: cpuSubtypeCode( + current.cpusubtype, + current.capabilities, + ), + cpu_subtype_base: cpuSubtypeBase(current.cpusubtype), + capabilities: current.capabilities ?? null, + file_offset: value(fields.offset), + size: value(fields.size), + alignment: value(fields.align), + }), + fields, + limitations, + }); + } + current = undefined; + observations = {}; + }; + for (const rawLine of output.split(/\r?\n/u)) { + const line = rawLine.trim(); + const count = /^nfat_arch\s+(\d+)(?:\s+\(\+(\d+) hidden\))?$/u.exec(line); + if (count?.[1] !== undefined) { + declaredArchitectureCount = integer(count[1]); + hiddenArchitectureCount = integer(count[2] ?? "0"); + continue; + } + if (line.startsWith("Non-fat file:")) { + flush(); + current = { "Non-fat file": line }; + continue; + } + if (line.startsWith("architecture ")) { + flush(); + current = { architecture: line.slice("architecture ".length).trim() }; + continue; + } + const numericField = /^\s*(offset|size|align)(?:\s+(.*))?$/u.exec(rawLine); + if ( + numericField?.[1] === "offset" || + numericField?.[1] === "size" || + numericField?.[1] === "align" + ) { + current ??= {}; + const field = numericField[1]; + // UTF-16 source, joined and rendered strings, worst-case escaped JSON, + // and per-observation bookkeeping fit the existing native output allowance. + // Charge before storing another observation; every source line is retained + // at most once per field and rendered at most once, never per duplicate pair. + admitFieldBytes(rawLine.length * 18 + 128); + const sourceValue = (numericField[2] ?? "").trim(); + const observed = { + sourceLine: rawLine, + value: + field === "align" ? alignment(sourceValue) : integer(sourceValue), + }; + (observations[field] ??= []).push(observed); + continue; + } + const match = /^(cputype|cpusubtype|capabilities)\s+(.+)$/u.exec(line); + if (match?.[1] !== undefined && match[2] !== undefined) { + current ??= {}; + current[match[1]] = match[2].trim(); + } + } + flush(); + if (architectures.length === 0) + throw malformedInput( + "lipo-output", + "lipo output contained no architectures", + ); + return { + format: "fat", + declaredArchitectureCount, + hiddenArchitectureCount, + architectures, + }; +}; + +/** Classify expected lipo parse failures once for all command adapters. */ +export const parseLipoOutputResult = ( + output: string, + operandPath?: string, +): Result< + LipoOutput, + ParseFailureError | z.ZodError | LipoFieldRetentionError +> => { + try { + return ok(parseLipoOutput(output, operandPath)); + } catch (cause: unknown) { + if ( + !(cause instanceof ParseFailureError) && + !(cause instanceof z.ZodError) && + !(cause instanceof LipoFieldRetentionError) + ) + throw cause; + return err(cause); + } +}; + +const integer = (value: string | undefined): number | null => { + if (value === undefined || !/^\d+$/u.test(value)) return null; + const parsed = Number.parseInt(value, 10); + return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : null; +}; + +const CPU_TYPES: Readonly> = { + CPU_TYPE_X86: 7, + CPU_TYPE_I386: 7, + CPU_TYPE_X86_64: 0x01000007, + CPU_TYPE_ARM: 12, + CPU_TYPE_ARM64: 0x0100000c, + CPU_TYPE_ARM64_32: 0x0200000c, + CPU_TYPE_POWERPC: 18, + CPU_TYPE_POWERPC64: 0x01000012, +}; + +const CPU_SUBTYPES: Readonly> = { + CPU_SUBTYPE_X86_ALL: 3, + CPU_SUBTYPE_I386_ALL: 3, + CPU_SUBTYPE_X86_64_ALL: 3, + CPU_SUBTYPE_X86_64_H: 8, + CPU_SUBTYPE_ARM64_ALL: 0, + CPU_SUBTYPE_ARM64_V8: 1, + CPU_SUBTYPE_ARM64E: 2, + CPU_SUBTYPE_ARM64_32_ALL: 0, + CPU_SUBTYPE_ARM64_32_V8: 1, + CPU_SUBTYPE_ARM_V7: 9, + CPU_SUBTYPE_ARM_V7S: 11, + CPU_SUBTYPE_ARM_V7K: 12, + CPU_SUBTYPE_POWERPC_ALL: 0, + CPU_SUBTYPE_POWERPC_970: 100, +}; + +/** Normalize known lipo names while retaining the producer's original text. */ +const ownCpuCode = ( + codes: Readonly>, + name: string, +): number | undefined => (Object.hasOwn(codes, name) ? codes[name] : undefined); + +const cpuTypeCode = (value: string | undefined): number | null => { + if (value === undefined) return null; + const numeric = unsigned32(value); + return numeric ?? ownCpuCode(CPU_TYPES, value) ?? null; +}; + +/** Normalize the subtype and its separately printed capability bits. */ +const cpuSubtypeCode = ( + value: string | undefined, + capabilities: string | undefined, +): number | null => { + if (value === undefined) return null; + const numeric = unsigned32(value); + if (numeric !== null) return numeric; + const subtype = ownCpuCode(CPU_SUBTYPES, value); + if (subtype === undefined) return null; + if (value !== "CPU_SUBTYPE_ARM64E") { + // Recent lipo prints an empty capabilities line, even for LIB64 slices. + const bits = capabilityBits(capabilities); + return bits === null ? null : ((bits << 24) | subtype) >>> 0; + } + const version = /PTR_AUTH_VERSION\s+USERSPACE\s+(\d+)/u.exec( + capabilities ?? "", + )?.[1]; + if (version === undefined) return null; + const parsedVersion = Number(version); + if ( + !Number.isInteger(parsedVersion) || + parsedVersion < 0 || + parsedVersion > 15 + ) + return null; + return (0x80000000 | (parsedVersion << 24) | subtype) >>> 0; +}; + +/** The subtype bits a lipo record names, without its capability byte. */ +const cpuSubtypeBase = (value: string | undefined): number | null => { + if (value === undefined) return null; + const subtype = unsigned32(value) ?? ownCpuCode(CPU_SUBTYPES, value); + return subtype === undefined ? null : machoCpuSubtypeBase(subtype); +}; + +/** lipo names the LIB64 capability and prints other capability bits in hex. */ +const capabilityBits = (capabilities: string | undefined): number | null => { + if (capabilities === "CPU_SUBTYPE_LIB64") return 0x80; + const bits = /^0x([\da-f]{1,2})$/iu.exec(capabilities ?? "")?.[1]; + return bits === undefined ? null : Number.parseInt(bits, 16); +}; + +const unsigned32 = (value: string): number | null => { + if (!/^(?:\d+|0x[\da-f]+)$/iu.test(value)) return null; + const parsed = Number(value); + return Number.isInteger(parsed) && parsed >= 0 && parsed <= 0xffffffff + ? parsed >>> 0 + : null; +}; + +const alignment = (value: string | undefined): number | null => { + if (value === undefined) return null; + const exponent = /^2\^(\d+)(?: \((\d+)\))?$/u.exec(value); + const powerText = exponent?.[1]; + if (powerText !== undefined) { + const power = Number.parseInt(powerText, 10); + if (power > 52) return null; + const alignment = 2 ** power; + const reported = exponent?.[2]; + return reported === undefined || integer(reported) === alignment + ? alignment + : null; + } + return integer(value); +}; diff --git a/src/domain/native/nativeCommandOutput.ts b/src/domain/native/nativeCommandOutput.ts new file mode 100644 index 0000000000..44e32f57c6 --- /dev/null +++ b/src/domain/native/nativeCommandOutput.ts @@ -0,0 +1,2 @@ +/** Retain complete native command output up to a bounded aggregate size. */ +export const NATIVE_COMMAND_OUTPUT_BUDGET_BYTES = 64 * 1024 * 1024; diff --git a/src/native/CommandRunner.ts b/src/native/CommandRunner.ts index 2bbfc10801..b52a1b7c34 100644 --- a/src/native/CommandRunner.ts +++ b/src/native/CommandRunner.ts @@ -20,14 +20,13 @@ import type { } from "../process/ProviderProcess.js"; import { utf8HeadExcerpt } from "../domain/utf8HeadExcerpt.js"; import { DEFAULT_NATIVE_COMMAND_TIMEOUT_MS } from "../domain/native/nativeDeadlines.js"; +import { NATIVE_COMMAND_OUTPUT_BUDGET_BYTES } from "../domain/native/nativeCommandOutput.js"; import { selectArtifactCommandPath, type ArtifactCommandPath, } from "../process/ArtifactCommandPath.js"; import { ArtifactReaderFailure } from "../resources/index.js"; -/** Retain complete command output up to a bounded aggregate size. */ -export const NATIVE_COMMAND_OUTPUT_BUDGET_BYTES = 64 * 1024 * 1024; /** * Failure diagnostics keep only an excerpt of each stream. Successful * analysis needs complete output, but a failed command's error would diff --git a/src/native/MachoArchitectureSelection.test.ts b/src/native/MachoArchitectureSelection.test.ts index 4db2de70a3..fa20def7b4 100644 --- a/src/native/MachoArchitectureSelection.test.ts +++ b/src/native/MachoArchitectureSelection.test.ts @@ -1,7 +1,7 @@ import { describe, expect, it } from "vitest"; import { selectLipoArchitecture } from "./MachoArchitectureSelection.js"; -import type { LipoArchitecture } from "./parsers/lipo.js"; +import type { LipoArchitecture } from "../domain/apple/lipo.js"; const record = ( name: string, diff --git a/src/native/MachoArchitectureSelection.ts b/src/native/MachoArchitectureSelection.ts index 52e2fa7c3d..fa3a8d4644 100644 --- a/src/native/MachoArchitectureSelection.ts +++ b/src/native/MachoArchitectureSelection.ts @@ -7,11 +7,11 @@ import { } from "../domain/apple/machoCpuIdentity.js"; import { keyedBy, uniqueKeyed } from "../domain/keyedCollection.js"; import { err, ok, type Result } from "../domain/result.js"; -import type { LipoArchitecture } from "./parsers/lipo.js"; import type { AdmittedMachoSlice, MachoSliceSelectionRefusal, } from "./metadata/MachoSliceSelection.js"; +import type { LipoArchitecture } from "../domain/apple/lipo.js"; /** Apple tool names for the domain-owned host subtype preference. */ const preferredSubtypes = ( diff --git a/src/native/NativeCommandAnalysisError.ts b/src/native/NativeCommandAnalysisError.ts index 529ead3ff9..2249856c8f 100644 --- a/src/native/NativeCommandAnalysisError.ts +++ b/src/native/NativeCommandAnalysisError.ts @@ -25,10 +25,10 @@ import { nativeDeadlineRecovery, } from "../domain/native/nativeDeadlines.js"; import { - NATIVE_COMMAND_OUTPUT_BUDGET_BYTES, NATIVE_FAILURE_DIAGNOSTIC_BYTES, type NativeCommandFailure, } from "./CommandRunner.js"; +import { NATIVE_COMMAND_OUTPUT_BUDGET_BYTES } from "../domain/native/nativeCommandOutput.js"; /** Operation-owned text for a command deadline or unavailable requirement. */ export interface NativeCommandFailurePresentation { diff --git a/src/native/NativeMacOSProvider.ts b/src/native/NativeMacOSProvider.ts index 2ad3ec7a1a..e88ff7d989 100644 --- a/src/native/NativeMacOSProvider.ts +++ b/src/native/NativeMacOSProvider.ts @@ -122,7 +122,6 @@ import { import { err, ok, type Result } from "../domain/result.js"; import { NativeCommandFailure, - NATIVE_COMMAND_OUTPUT_BUDGET_BYTES, XcrunCommandRunner, failureCapture, type NativeCommandCleanupFailure, @@ -173,6 +172,7 @@ import { import { NativeUiInterruptionControl } from "./NativeUiInterruptionControl.js"; import type { ResolvedAppBundleResourceRoot } from "../domain/apple/bundleResourceRoot.js"; import { UnsupportedBinaryPlistUidError } from "../domain/apple/plistScalars.js"; +import { NATIVE_COMMAND_OUTPUT_BUDGET_BYTES } from "../domain/native/nativeCommandOutput.js"; type SignatureRuntimeRootFactory = () => Promise< Pick diff --git a/src/native/NativeMachoInspection.ts b/src/native/NativeMachoInspection.ts index 71d788d751..06b95f2d65 100644 --- a/src/native/NativeMachoInspection.ts +++ b/src/native/NativeMachoInspection.ts @@ -16,10 +16,7 @@ import { machoRuntimeSymbolName } from "../domain/native/machoSymbolName.js"; import { keyedBy, uniqueKeyed } from "../domain/keyedCollection.js"; import { err, ok, type Result } from "../domain/result.js"; import type { MachoSliceSelectionRefusal } from "./metadata/MachoSliceSelection.js"; -import { - NATIVE_COMMAND_OUTPUT_BUDGET_BYTES, - type NativeCommandCapture, -} from "./CommandRunner.js"; +import type { NativeCommandCapture } from "./CommandRunner.js"; import { chainedImportNames } from "./AppleMachoFixups.js"; import { architectureBaseName, @@ -31,7 +28,7 @@ import { parseDyldExports, parseDyldImports, } from "./parsers/dyldInfo.js"; -import { parseLipoCapture, type LipoArchitecture } from "./parsers/lipo.js"; +import { parseLipoCapture } from "./parsers/lipo.js"; import { withoutEchoedPathHeader } from "./parsers/echoedPath.js"; import { projectMachoBinary, @@ -59,6 +56,8 @@ import { unusableNativeCommandOutput, } from "./NativeMachoCommandDiagnostics.js"; import { invariantViolation } from "../domain/internalInvariant.js"; +import { NATIVE_COMMAND_OUTPUT_BUDGET_BYTES } from "../domain/native/nativeCommandOutput.js"; +import type { LipoArchitecture } from "../domain/apple/lipo.js"; interface NativeMachoObservation { readonly result: JsonValue; diff --git a/src/native/NativeMachoSelectedSlice.test.ts b/src/native/NativeMachoSelectedSlice.test.ts index 9b5c06061d..91f2c12da6 100644 --- a/src/native/NativeMachoSelectedSlice.test.ts +++ b/src/native/NativeMachoSelectedSlice.test.ts @@ -3,8 +3,8 @@ import { assertSelectedMachoSlice, resolveSelectedMachoSlice, } from "./NativeMachoSelectedSlice.js"; -import { parseLipoOutputResult } from "./parsers/lipo.js"; import type { MachoCommandNames } from "./MachoCommandNames.js"; +import { parseLipoOutputResult } from "../domain/apple/lipo.js"; it("binds the lipo row to one FAT entry and its selected thin header", async () => { const bytes = Buffer.alloc(256); diff --git a/src/native/NativeMachoSelectedSlice.ts b/src/native/NativeMachoSelectedSlice.ts index 51d3c736fe..df965042f7 100644 --- a/src/native/NativeMachoSelectedSlice.ts +++ b/src/native/NativeMachoSelectedSlice.ts @@ -11,7 +11,7 @@ import { type MachoCommandNames, } from "./MachoCommandNames.js"; import type { NativeMachoSource } from "./NativeMachoSource.js"; -import type { LipoArchitecture } from "./parsers/lipo.js"; +import type { LipoArchitecture } from "../domain/apple/lipo.js"; export interface ResolvedMachoSlice { readonly offset: number; diff --git a/src/native/parsers/lipo.test.ts b/src/native/parsers/lipo.test.ts index 9191c4615a..43c88ed137 100644 --- a/src/native/parsers/lipo.test.ts +++ b/src/native/parsers/lipo.test.ts @@ -1,25 +1,6 @@ -import { describe, expect, it } from "vitest"; +import { expect, it } from "vitest"; import { parseLipoCapture } from "./lipo.js"; -import { parseLipoFixture } from "../../../tests/fixtures/lipo.js"; - -const fatRecords = `fat_magic 0xcafebabe -nfat_arch 2 -architecture arm64 - cputype CPU_TYPE_ARM64 - cpusubtype CPU_SUBTYPE_ARM64_ALL - capabilities 0x0 - offset 4096 - size 32 - align 2^12 (4096) -architecture x86_64 - cputype CPU_TYPE_X86_64 - cpusubtype CPU_SUBTYPE_X86_64_ALL - capabilities 0x0 - offset 8192 - size 32 - align 2^12 (4096) -`; it("retains native command capture when shared lipo parsing rejects records", () => { const capture = { @@ -60,364 +41,3 @@ it("retains native command capture when shared lipo parsing rejects records", () }, }); }); - -describe("lipo numeric field observations", () => { - it.each([ - { field: "offset", source: "-1" }, - { field: "size", source: "9007199254740992" }, - { field: "align", source: "2^12 (2048)" }, - { field: "align", source: "2^53" }, - { field: "offset", source: "" }, - ] as const)( - "retains an explicit uninterpretable $field source: $source", - ({ field, source }) => { - const sourceLine = `\t${field} ${source} `; - const architecture = parseLipoFixture( - `architecture arm64\n cputype 16777228\n${sourceLine}\n`, - ).architectures[0]; - expect(architecture?.cpu_type_code).toBe(16777228); - expect(architecture?.fields[field]).toEqual({ - kind: "uninterpretable", - sourceLines: [sourceLine], - }); - expect(architecture?.limitations).toHaveLength(1); - expect(architecture?.limitations[0]).toContain(sourceLine); - expect(architecture?.limitations[0]).toContain(field); - expect(architecture?.limitations[0]).toMatch( - /lipo.*arm64.*could not be interpreted/iu, - ); - }, - ); - - it("parses each valid numeric field once while preserving its exact source line", () => { - const architecture = parseLipoFixture( - "architecture arm64\n offset 4096 \n size 48\n align 2^12 (4096)\n", - ).architectures[0]; - expect(architecture).toMatchObject({ - file_offset: 4096, - size: 48, - alignment: 4096, - limitations: [], - fields: { - offset: { - kind: "parsed", - sourceLines: [" offset 4096 "], - value: 4096, - }, - size: { kind: "parsed", sourceLines: [" size 48"], value: 48 }, - align: { - kind: "parsed", - sourceLines: [" align 2^12 (4096)"], - value: 4096, - }, - }, - }); - }); - - it.each(["offset", "size", "align"] as const)( - "retains every repeated %s declaration and requires their parsed values to agree", - (field) => { - const first = field === "align" ? "2^12 (4096)" : "4096"; - const conflicting = field === "align" ? "2^13 (8192)" : "8192"; - for (const second of [first, conflicting, "unsupported"]) { - const sourceLines = [` ${field} ${first}`, `\t${field} ${second} `]; - const row = parseLipoFixture( - `architecture arm64\n${sourceLines.join("\n")}\n`, - ).architectures[0]; - expect(row?.fields[field]).toEqual( - second === first - ? { kind: "parsed", sourceLines, value: 4096 } - : { kind: "uninterpretable", sourceLines }, - ); - if (second === first) expect(row?.limitations).toEqual([]); - else { - expect(row?.limitations).toHaveLength(1); - for (const line of sourceLines) - expect(row?.limitations[0]).toContain(line); - } - } - }, - ); -}); - -it.each([ - { - type: "constructor", - subtype: "CPU_SUBTYPE_ARM64_ALL", - typeCode: null, - subtypeCode: 0, - subtypeBase: 0, - }, - { - type: "CPU_TYPE_ARM64", - subtype: "toString", - typeCode: 0x0100000c, - subtypeCode: null, - subtypeBase: null, - }, -])( - "preserves unknown CPU names without inventing codes", - ({ type, subtype, typeCode, subtypeCode, subtypeBase }) => { - const { architectures } = parseLipoFixture( - fatRecords - .replace("CPU_TYPE_ARM64", type) - .replace("CPU_SUBTYPE_ARM64_ALL", subtype), - ); - expect(architectures[0]).toMatchObject({ - cpu_type: type, - cpu_type_code: typeCode, - cpu_subtype: subtype, - cpu_subtype_code: subtypeCode, - cpu_subtype_base: subtypeBase, - }); - }, -); - -describe("lipo architecture facts", () => { - it("preserves Apple's declared and hidden ARM64 architecture scopes", () => { - const output = parseLipoFixture(`fat_magic 0xcafebabe -nfat_arch 1 (+1 hidden) -architecture armv7 - cputype CPU_TYPE_ARM - cpusubtype CPU_SUBTYPE_ARM_V7 - offset 4096 - size 28 - align 2^12 (4096) -architecture arm64 (hidden) - cputype CPU_TYPE_ARM64 - cpusubtype CPU_SUBTYPE_ARM64_ALL - offset 8192 - size 32 - align 2^12 (4096) -`); - expect(output).toMatchObject({ - declaredArchitectureCount: 1, - hiddenArchitectureCount: 1, - architectures: [ - { name: "armv7", hidden: false }, - { name: "arm64", hidden: true, file_offset: 8192, size: 32 }, - ], - }); - }); - - it("normalizes symbolic CPU fields and arm64e capability bits", () => { - const { format, architectures } = parseLipoFixture(`Fat header in: /bin/ls -fat_magic 0xcafebabe -nfat_arch 2 -architecture x86_64 - cputype CPU_TYPE_X86_64 - cpusubtype CPU_SUBTYPE_X86_64_ALL - capabilities 0x0 - offset 16384 - size 48112 - align 2^14 (16384) -architecture arm64e - cputype CPU_TYPE_ARM64 - cpusubtype CPU_SUBTYPE_ARM64E - capabilities PTR_AUTH_VERSION USERSPACE 0 - offset 65536 - size 89088 - align 2^14 (16384) -`); - expect(format).toBe("fat"); - expect(architectures).toEqual([ - expect.objectContaining({ - name: "x86_64", - cpu_type: "CPU_TYPE_X86_64", - cpu_type_code: 0x01000007, - cpu_subtype: "CPU_SUBTYPE_X86_64_ALL", - cpu_subtype_code: 3, - capabilities: "0x0", - file_offset: 16384, - size: 48112, - alignment: 16384, - }), - expect.objectContaining({ - name: "arm64e", - cpu_type: "CPU_TYPE_ARM64", - cpu_type_code: 0x0100000c, - cpu_subtype: "CPU_SUBTYPE_ARM64E", - cpu_subtype_code: 0x80000002, - capabilities: "PTR_AUTH_VERSION USERSPACE 0", - file_offset: 65536, - size: 89088, - alignment: 16384, - }), - ]); - }); - - it("normalizes the CPU names lipo prints for i386 slices", () => { - // cctools misc/lipo.c print_cputype() spells i386 with I386 names. - expect( - parseLipoFixture(`architecture i386 - cputype CPU_TYPE_I386 - cpusubtype CPU_SUBTYPE_I386_ALL - capabilities 0x0 - offset 16384 - size 28 - align 2^14 (16384) -`).architectures, - ).toMatchObject([ - { - name: "i386", - cpu_type_code: 7, - cpu_subtype_code: 3, - cpu_subtype_base: 3, - }, - ]); - }); - - it("keeps unknown symbolic CPU values as source text without a code", () => { - expect( - parseLipoFixture( - "architecture future\n cputype CPU_TYPE_FUTURE\n cpusubtype CPU_SUBTYPE_FUTURE\n offset 4096\n size 64\n align 2^12\n", - ).architectures, - ).toMatchObject([ - { - cpu_type: "CPU_TYPE_FUTURE", - cpu_type_code: null, - cpu_subtype: "CPU_SUBTYPE_FUTURE", - cpu_subtype_code: null, - cpu_subtype_base: null, - }, - ]); - }); - - it.each([ - ["CPU_SUBTYPE_LIB64", 0x80000003], - ["0x80", 0x80000003], - ["0x0", 3], - ])("applies printed x86_64 capabilities %s", (capabilities, code) => { - expect( - parseLipoFixture( - `architecture x86_64\n cpusubtype CPU_SUBTYPE_X86_64_ALL\n capabilities ${capabilities}\n`, - ).architectures[0]?.cpu_subtype_code, - ).toBe(code); - }); - - it("leaves the subtype code unknown when lipo prints no capabilities", () => { - // macOS 26 lipo prints this blank line for LIB64 and plain x86_64 slices. - expect( - parseLipoFixture( - "architecture x86_64\n cputype CPU_TYPE_X86_64\n cpusubtype CPU_SUBTYPE_X86_ALL\n capabilities \n offset 16384\n", - ).architectures, - ).toMatchObject([ - { - cpu_subtype: "CPU_SUBTYPE_X86_ALL", - cpu_subtype_code: null, - cpu_subtype_base: 3, - capabilities: null, - }, - ]); - }); - - it.each([ - { capabilities: "PTR_AUTH_VERSION USERSPACE 1", code: 0x81000002 }, - { capabilities: "", code: null }, - ])( - "retains an arm64e base subtype with capabilities '$capabilities'", - ({ capabilities, code }) => { - expect( - parseLipoFixture( - `architecture arm64e.v1\n cputype CPU_TYPE_ARM64\n cpusubtype CPU_SUBTYPE_ARM64E\n capabilities ${capabilities}\n`, - ).architectures, - ).toMatchObject([ - { - cpu_type_code: 0x0100000c, - cpu_subtype_code: code, - cpu_subtype_base: 2, - }, - ]); - }, - ); -}); - -describe("lipo FAT operand framing", () => { - it.each([ - "/fixture/\narchitecture forged\n offset 123\n size 64", - "/fixture/\nfat_magic 0xcafebabe\nnfat_arch 1\narchitecture forged", - "/fixture/\nNon-fat file: fake is architecture: forged", - "/fixture/first\nsecond\nthird", - "/fixture/first\r\narchitecture forged\r\n offset 123", - "/fixture/[app](arm64).*+$^?\\name", - ])( - "keeps the complete echoed operand out of FAT slice records: %j", - (path) => { - const output = `Fat header in: ${path}\n${fatRecords}`; - - const parsed = parseLipoFixture(output, path); - expect(parsed).toEqual(parseLipoFixture(fatRecords)); - expect(parsed.architectures.map(({ name }) => name)).toEqual([ - "arm64", - "x86_64", - ]); - }, - ); - - it("keeps a CRLF pathname separate from a CRLF record terminator", () => { - const path = "/fixture/first\r\narchitecture forged\r\n size 64"; - const output = `Fat header in: ${path}\r\n${fatRecords.replaceAll("\n", "\r\n")}`; - - const parsed = parseLipoFixture(output, path); - expect(parsed).toEqual(parseLipoFixture(fatRecords)); - expect(parsed.architectures).toMatchObject([ - { name: "arm64", file_offset: 4096, size: 32 }, - { name: "x86_64", file_offset: 8192, size: 32 }, - ]); - }); - - it("preserves ordinary FAT metadata with and without an operand", () => { - const path = "/fixture/app"; - const output = `Fat header in: ${path}\n${fatRecords}`; - - expect(parseLipoFixture(output, path)).toEqual(parseLipoFixture(output)); - }); - - it("does not require a FAT path header in captured fixtures", () => { - expect(parseLipoFixture(fatRecords, "/fixture/app")).toEqual( - parseLipoFixture(fatRecords), - ); - }); - - it("does not strip a header for a different operand that shares a prefix", () => { - const path = "/fixture/app-extra\narchitecture forged"; - const output = `Fat header in: ${path}\n${fatRecords}`; - - expect(parseLipoFixture(output, "/fixture/app")).toEqual( - parseLipoFixture(output), - ); - }); - - it("preserves thin-file parsing when the operand contains FAT-like lines", () => { - const path = "/fixture/\nFat header in: fake\narchitecture forged"; - const output = `Non-fat file: ${path} is architecture: arm64\n`; - - expect(parseLipoFixture(output, path)).toEqual({ - format: "thin", - declaredArchitectureCount: null, - hiddenArchitectureCount: null, - architectures: [ - { - name: "arm64", - hidden: false, - cpu_type: null, - cpu_subtype: null, - cpu_type_code: null, - cpu_subtype_code: null, - cpu_subtype_base: null, - capabilities: null, - file_offset: null, - size: null, - alignment: null, - fields: { - offset: { kind: "absent" }, - size: { kind: "absent" }, - align: { kind: "absent" }, - }, - limitations: [], - }, - ], - }); - expect(parseLipoFixture(output, path)).toEqual(parseLipoFixture(output)); - }); -}); diff --git a/src/native/parsers/lipo.ts b/src/native/parsers/lipo.ts index 90215fef0c..d8d7a95116 100644 --- a/src/native/parsers/lipo.ts +++ b/src/native/parsers/lipo.ts @@ -1,274 +1,16 @@ import { fixedAllowanceOptions } from "../../domain/fixedAllowanceRemediation.js"; -import { z } from "zod"; import { AnalysisOutputError, AnalysisResourceConstraintError, } from "../../domain/analysisErrorCore.js"; -import { err, ok, type Result } from "../../domain/result.js"; +import { err, type Result } from "../../domain/result.js"; import { - malformedInput, - ParseFailureError, -} from "../../domain/parseFailure.js"; -import { - NATIVE_COMMAND_OUTPUT_BUDGET_BYTES, - type NativeCommandCapture, -} from "../CommandRunner.js"; -import { machoCpuSubtypeBase } from "../../domain/apple/machoCpuIdentity.js"; - -const architectureSchema = z.object({ - name: z.string().min(1), - hidden: z.boolean(), - cpu_type: z.string().nullable(), - cpu_subtype: z.string().nullable(), - cpu_type_code: z.int().nonnegative().nullable(), - cpu_subtype_code: z.int().nonnegative().nullable(), - cpu_subtype_base: z.int().nonnegative().nullable(), - capabilities: z.string().nullable(), - file_offset: z.int().min(0).nullable(), - size: z.int().min(0).nullable(), - alignment: z.int().min(0).nullable(), -}); - -export type LipoFieldObservation = - | { readonly kind: "absent" } - | { - readonly kind: "parsed"; - readonly sourceLines: readonly string[]; - readonly value: number; - } - | { - readonly kind: "uninterpretable"; - readonly sourceLines: readonly string[]; - }; - -export type LipoArchitecture = z.infer & { - readonly fields: Readonly< - Record<"offset" | "size" | "align", LipoFieldObservation> - >; - readonly limitations: readonly string[]; -}; - -/** Capacity refusal before retaining expanded per-declaration source facts. */ -export class LipoFieldRetentionError extends Error { - readonly _tag = "LipoFieldRetentionError"; - constructor(readonly requiredBytes: number) { - super( - "lipo numeric field observations exceed the retained native output budget", - ); - this.name = this._tag; - } -} - -interface LipoOutput { - readonly format: "thin" | "fat"; - /** `nfat_arch` counts visible rows; Apple may append one hidden ARM64 row. */ - readonly declaredArchitectureCount: number | null; - readonly hiddenArchitectureCount: number | null; - readonly architectures: LipoArchitecture[]; -} - -/** Parse `lipo -detailed_info` framing and deterministic slice metadata. */ -const parseLipoOutput = (output: string, operandPath?: string): LipoOutput => { - // The echoed FAT operand is one value, even when its pathname contains lines. - if (operandPath !== undefined) { - const header = `Fat header in: ${operandPath}`; - if (output.startsWith(header)) { - if (output.startsWith("\r\n", header.length)) - output = output.slice(header.length + 2); - else if (output.startsWith("\n", header.length)) - output = output.slice(header.length + 1); - } - } - // lipo echoes a thin file's pathname verbatim, including embedded newlines. - // Match its final architecture field before splitting records into lines. - const thinArchitecture = - /(?:^|\r?\n)Non-fat file:[\s\S]* is architecture: ([^\s]+)\s*$/u.exec( - output, - )?.[1]; - if (thinArchitecture !== undefined) - return { - format: "thin", - declaredArchitectureCount: null, - hiddenArchitectureCount: null, - architectures: [ - { - ...architectureSchema.parse({ - name: thinArchitecture, - hidden: false, - cpu_type: null, - cpu_subtype: null, - cpu_type_code: null, - cpu_subtype_code: null, - cpu_subtype_base: null, - capabilities: null, - file_offset: null, - size: null, - alignment: null, - }), - fields: { - offset: { kind: "absent" }, - size: { kind: "absent" }, - align: { kind: "absent" }, - }, - limitations: [], - }, - ], - }; - const architectures: LipoArchitecture[] = []; - let declaredArchitectureCount: number | null = null; - let hiddenArchitectureCount: number | null = null; - let current: Record | undefined; - let observations: Partial< - Record< - "offset" | "size" | "align", - { readonly sourceLine: string; readonly value: number | null }[] - > - > = {}; - let retainedFieldBytes = 0; - const admitFieldBytes = (bytes: number): void => { - retainedFieldBytes += bytes; - if (retainedFieldBytes > NATIVE_COMMAND_OUTPUT_BUDGET_BYTES) - throw new LipoFieldRetentionError(retainedFieldBytes); - }; - const flush = (): void => { - if (current === undefined) return; - const name = current.architecture ?? current["Non-fat file"]; - if (name !== undefined) { - const observe = ( - key: "offset" | "size" | "align", - ): LipoFieldObservation => { - const observed = observations[key]; - if (observed === undefined) return { kind: "absent" }; - const sourceLines = observed.map(({ sourceLine }) => sourceLine); - const value = observed[0]?.value; - return value === null || - value === undefined || - observed.some((candidate) => candidate.value !== value) - ? { kind: "uninterpretable", sourceLines } - : { kind: "parsed", sourceLines, value }; - }; - const fields = { - offset: observe("offset"), - size: observe("size"), - align: observe("align"), - }; - const value = (field: LipoFieldObservation): number | null => - field.kind === "parsed" ? field.value : null; - const limitations = Object.entries(fields).flatMap( - ([field, observation]) => { - if (observation.kind !== "uninterpretable") return []; - admitFieldBytes(name.length * 14 + 256); - return [ - `lipo ${field} for ${name} could not be interpreted; ${observation.sourceLines.length === 1 ? "source line: " : "source lines:\n"}${observation.sourceLines.join("\n")}`, - ]; - }, - ); - architectures.push({ - ...architectureSchema.parse({ - name: name.includes(" is architecture: ") - ? (name.split(" is architecture: ").at(-1) ?? name) - : name.replace(/ \(hidden\)$/u, ""), - hidden: name.endsWith(" (hidden)"), - cpu_type: current.cputype ?? null, - cpu_subtype: current.cpusubtype ?? null, - cpu_type_code: cpuTypeCode(current.cputype), - cpu_subtype_code: cpuSubtypeCode( - current.cpusubtype, - current.capabilities, - ), - cpu_subtype_base: cpuSubtypeBase(current.cpusubtype), - capabilities: current.capabilities ?? null, - file_offset: value(fields.offset), - size: value(fields.size), - alignment: value(fields.align), - }), - fields, - limitations, - }); - } - current = undefined; - observations = {}; - }; - for (const rawLine of output.split(/\r?\n/u)) { - const line = rawLine.trim(); - const count = /^nfat_arch\s+(\d+)(?:\s+\(\+(\d+) hidden\))?$/u.exec(line); - if (count?.[1] !== undefined) { - declaredArchitectureCount = integer(count[1]); - hiddenArchitectureCount = integer(count[2] ?? "0"); - continue; - } - if (line.startsWith("Non-fat file:")) { - flush(); - current = { "Non-fat file": line }; - continue; - } - if (line.startsWith("architecture ")) { - flush(); - current = { architecture: line.slice("architecture ".length).trim() }; - continue; - } - const numericField = /^\s*(offset|size|align)(?:\s+(.*))?$/u.exec(rawLine); - if ( - numericField?.[1] === "offset" || - numericField?.[1] === "size" || - numericField?.[1] === "align" - ) { - current ??= {}; - const field = numericField[1]; - // UTF-16 source, joined and rendered strings, worst-case escaped JSON, - // and per-observation bookkeeping fit the existing native output allowance. - // Charge before storing another observation; every source line is retained - // at most once per field and rendered at most once, never per duplicate pair. - admitFieldBytes(rawLine.length * 18 + 128); - const sourceValue = (numericField[2] ?? "").trim(); - const observed = { - sourceLine: rawLine, - value: - field === "align" ? alignment(sourceValue) : integer(sourceValue), - }; - (observations[field] ??= []).push(observed); - continue; - } - const match = /^(cputype|cpusubtype|capabilities)\s+(.+)$/u.exec(line); - if (match?.[1] !== undefined && match[2] !== undefined) { - current ??= {}; - current[match[1]] = match[2].trim(); - } - } - flush(); - if (architectures.length === 0) - throw malformedInput( - "lipo-output", - "lipo output contained no architectures", - ); - return { - format: "fat", - declaredArchitectureCount, - hiddenArchitectureCount, - architectures, - }; -}; - -/** Classify expected lipo parse failures once for all command adapters. */ -export const parseLipoOutputResult = ( - output: string, - operandPath?: string, -): Result< - LipoOutput, - ParseFailureError | z.ZodError | LipoFieldRetentionError -> => { - try { - return ok(parseLipoOutput(output, operandPath)); - } catch (cause: unknown) { - if ( - !(cause instanceof ParseFailureError) && - !(cause instanceof z.ZodError) && - !(cause instanceof LipoFieldRetentionError) - ) - throw cause; - return err(cause); - } -}; + LipoFieldRetentionError, + parseLipoOutputResult, + type LipoOutput, +} from "../../domain/apple/lipo.js"; +import { NATIVE_COMMAND_OUTPUT_BUDGET_BYTES } from "../../domain/native/nativeCommandOutput.js"; +import type { NativeCommandCapture } from "../CommandRunner.js"; /** Translate classified parse failure into native command output failure. */ export const parseLipoCapture = ( @@ -322,116 +64,3 @@ export const parseLipoCapture = ( ), ); }; - -const integer = (value: string | undefined): number | null => { - if (value === undefined || !/^\d+$/u.test(value)) return null; - const parsed = Number.parseInt(value, 10); - return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : null; -}; - -const CPU_TYPES: Readonly> = { - CPU_TYPE_X86: 7, - CPU_TYPE_I386: 7, - CPU_TYPE_X86_64: 0x01000007, - CPU_TYPE_ARM: 12, - CPU_TYPE_ARM64: 0x0100000c, - CPU_TYPE_ARM64_32: 0x0200000c, - CPU_TYPE_POWERPC: 18, - CPU_TYPE_POWERPC64: 0x01000012, -}; - -const CPU_SUBTYPES: Readonly> = { - CPU_SUBTYPE_X86_ALL: 3, - CPU_SUBTYPE_I386_ALL: 3, - CPU_SUBTYPE_X86_64_ALL: 3, - CPU_SUBTYPE_X86_64_H: 8, - CPU_SUBTYPE_ARM64_ALL: 0, - CPU_SUBTYPE_ARM64_V8: 1, - CPU_SUBTYPE_ARM64E: 2, - CPU_SUBTYPE_ARM64_32_ALL: 0, - CPU_SUBTYPE_ARM64_32_V8: 1, - CPU_SUBTYPE_ARM_V7: 9, - CPU_SUBTYPE_ARM_V7S: 11, - CPU_SUBTYPE_ARM_V7K: 12, - CPU_SUBTYPE_POWERPC_ALL: 0, - CPU_SUBTYPE_POWERPC_970: 100, -}; - -/** Normalize known lipo names while retaining the producer's original text. */ -const ownCpuCode = ( - codes: Readonly>, - name: string, -): number | undefined => (Object.hasOwn(codes, name) ? codes[name] : undefined); - -const cpuTypeCode = (value: string | undefined): number | null => { - if (value === undefined) return null; - const numeric = unsigned32(value); - return numeric ?? ownCpuCode(CPU_TYPES, value) ?? null; -}; - -/** Normalize the subtype and its separately printed capability bits. */ -const cpuSubtypeCode = ( - value: string | undefined, - capabilities: string | undefined, -): number | null => { - if (value === undefined) return null; - const numeric = unsigned32(value); - if (numeric !== null) return numeric; - const subtype = ownCpuCode(CPU_SUBTYPES, value); - if (subtype === undefined) return null; - if (value !== "CPU_SUBTYPE_ARM64E") { - // Recent lipo prints an empty capabilities line, even for LIB64 slices. - const bits = capabilityBits(capabilities); - return bits === null ? null : ((bits << 24) | subtype) >>> 0; - } - const version = /PTR_AUTH_VERSION\s+USERSPACE\s+(\d+)/u.exec( - capabilities ?? "", - )?.[1]; - if (version === undefined) return null; - const parsedVersion = Number(version); - if ( - !Number.isInteger(parsedVersion) || - parsedVersion < 0 || - parsedVersion > 15 - ) - return null; - return (0x80000000 | (parsedVersion << 24) | subtype) >>> 0; -}; - -/** The subtype bits a lipo record names, without its capability byte. */ -const cpuSubtypeBase = (value: string | undefined): number | null => { - if (value === undefined) return null; - const subtype = unsigned32(value) ?? ownCpuCode(CPU_SUBTYPES, value); - return subtype === undefined ? null : machoCpuSubtypeBase(subtype); -}; - -/** lipo names the LIB64 capability and prints other capability bits in hex. */ -const capabilityBits = (capabilities: string | undefined): number | null => { - if (capabilities === "CPU_SUBTYPE_LIB64") return 0x80; - const bits = /^0x([\da-f]{1,2})$/iu.exec(capabilities ?? "")?.[1]; - return bits === undefined ? null : Number.parseInt(bits, 16); -}; - -const unsigned32 = (value: string): number | null => { - if (!/^(?:\d+|0x[\da-f]+)$/iu.test(value)) return null; - const parsed = Number(value); - return Number.isInteger(parsed) && parsed >= 0 && parsed <= 0xffffffff - ? parsed >>> 0 - : null; -}; - -const alignment = (value: string | undefined): number | null => { - if (value === undefined) return null; - const exponent = /^2\^(\d+)(?: \((\d+)\))?$/u.exec(value); - const powerText = exponent?.[1]; - if (powerText !== undefined) { - const power = Number.parseInt(powerText, 10); - if (power > 52) return null; - const alignment = 2 ** power; - const reported = exponent?.[2]; - return reported === undefined || integer(reported) === alignment - ? alignment - : null; - } - return integer(value); -}; diff --git a/tests/boundary/providers/native/lipoFieldOwnership.test.ts b/tests/boundary/providers/native/lipoFieldOwnership.test.ts index 4904253c1b..03245749b4 100644 --- a/tests/boundary/providers/native/lipoFieldOwnership.test.ts +++ b/tests/boundary/providers/native/lipoFieldOwnership.test.ts @@ -17,15 +17,13 @@ import { nativeMachoTargetForFile, } from "../../../fixtures/nativeCommands.js"; import { createTestTempDirectory } from "../../../fixtures/temporaryDirectory.js"; -import { NATIVE_COMMAND_OUTPUT_BUDGET_BYTES } from "../../../../src/native/CommandRunner.js"; -import { - LipoFieldRetentionError, - parseLipoCapture, -} from "../../../../src/native/parsers/lipo.js"; +import { parseLipoCapture } from "../../../../src/native/parsers/lipo.js"; import { ArtifactReaderFailure, type ArtifactEntry, } from "../../../../src/resources/ArtifactReader.js"; +import { NATIVE_COMMAND_OUTPUT_BUDGET_BYTES } from "../../../../src/domain/native/nativeCommandOutput.js"; +import { LipoFieldRetentionError } from "../../../../src/domain/apple/lipo.js"; it.each(["absent", "valid", "uninterpretable"] as const)( "preserves %s lipo fields through native observations and structural slice inventory", diff --git a/tests/boundary/providers/native/nativeProvider.test.ts b/tests/boundary/providers/native/nativeProvider.test.ts index 998369c792..3e81ba6102 100644 --- a/tests/boundary/providers/native/nativeProvider.test.ts +++ b/tests/boundary/providers/native/nativeProvider.test.ts @@ -16,7 +16,6 @@ import { createTestTempDirectory } from "../../../fixtures/temporaryDirectory.js import { NativeMacOSProvider } from "../../../../src/native/NativeMacOSProvider.js"; import { - NATIVE_COMMAND_OUTPUT_BUDGET_BYTES, NATIVE_FAILURE_DIAGNOSTIC_BYTES, NativeCommandFailure, XcrunCommandRunner, @@ -56,6 +55,7 @@ import { nativeResolvedToolFixture, } from "../../../fixtures/nativeCommands.js"; import { releaseOwnedCleanup } from "../../../support/cleanupRelease.js"; +import { NATIVE_COMMAND_OUTPUT_BUDGET_BYTES } from "../../../../src/domain/native/nativeCommandOutput.js"; /** The file runner identifies selected .plist inputs as XML. */ const writeFixturePlist = async (path: string): Promise => { diff --git a/tests/boundary/providers/native/nativeTextRobustness.test.ts b/tests/boundary/providers/native/nativeTextRobustness.test.ts index f4349e6f3c..8c2e24a984 100644 --- a/tests/boundary/providers/native/nativeTextRobustness.test.ts +++ b/tests/boundary/providers/native/nativeTextRobustness.test.ts @@ -1,7 +1,7 @@ import { expect, it } from "vitest"; import { readPlistJson } from "../../../../src/native/parsers/plist.js"; -import { parseLipoOutputResult } from "../../../../src/native/parsers/lipo.js"; +import { parseLipoOutputResult } from "../../../../src/domain/apple/lipo.js"; it.each([ "line\nbreak", diff --git a/tests/fixtures/lipo.ts b/tests/fixtures/lipo.ts index fefd7cf9d6..a07db50f61 100644 --- a/tests/fixtures/lipo.ts +++ b/tests/fixtures/lipo.ts @@ -1,4 +1,4 @@ -import { parseLipoOutputResult } from "../../src/native/parsers/lipo.js"; +import { parseLipoOutputResult } from "../../src/domain/apple/lipo.js"; /** Unwrap the production parser boundary for fixture setup and error assertions. */ export const parseLipoFixture = (output: string, operandPath?: string) => {