@invarn/cibuild 2.7.9 → 2.8.1

package/dist/src/commands/ios-scanner.js

@@ -1,5 +1,6 @@
 import { resolve, relative } from "node:path";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { xcodeContainersIn } from "../shared/detect-project.js";
 // ---------------------------------------------------------------------------
 // File discovery
 // ---------------------------------------------------------------------------
@@ -18,17 +19,16 @@ function relPath(root, filePath) {
  * Finds the primary Xcode project path.
  * Prefers .xcworkspace over .xcodeproj (CocoaPods projects use workspace).
  * Returns the relative path from root, or empty string if not found.
+ *
+ * A candidate must be a real container — `isXcodeContainer` — and not merely
+ * a directory with the right suffix. `Uwi0/Oakane` ships `iosApp.xcodeproj`
+ * with no `project.pbxproj` beside the `oakane.xcodeproj` that has one, and
+ * this function returned the husk because it was first.
  */
 function findXcodeProjectPath(root) {
-    let entries;
-    try {
-        entries = readdirSync(root);
-    }
-    catch {
-        return "";
-    }
-    const workspaces = entries.filter((e) => e.endsWith(".xcworkspace"));
-    const projects = entries.filter((e) => e.endsWith(".xcodeproj"));
+    const containers = xcodeContainersIn(root);
+    const workspaces = containers.filter((e) => e.endsWith(".xcworkspace"));
+    const projects = containers.filter((e) => e.endsWith(".xcodeproj"));
     // Prefer workspace (CocoaPods / multi-package setups use these)
     if (workspaces.length > 0)
         return workspaces[0];
@@ -43,14 +43,7 @@ function findXcodeProjectPath(root) {
  */
 const COMPANION_SCHEME = /(extension|widget|clip|intents?|notification|tvos|macos|watchos|visionos|tests?|screenshots?|staging|prototype|codegen)/i;
 function readSchemeFacts(root, name) {
-    let entries;
-    try {
-        entries = readdirSync(root);
-    }
-    catch {
-        return undefined;
-    }
-    for (const entry of entries) {
+    for (const entry of xcodeContainersIn(root)) {
         if (!entry.endsWith(".xcodeproj"))
             continue;
         const path = resolve(root, entry, "xcshareddata", "xcschemes", `${name}.xcscheme`);
@@ -194,13 +187,11 @@ export function rankSchemesWithReason(root, projectPath, schemes) {
  */
 function detectSchemes(root) {
     const schemes = new Set();
-    let entries;
-    try {
-        entries = readdirSync(root);
-    }
-    catch {
-        return [];
-    }
+    // Real projects only. The fallback below invents a scheme from the
+    // directory's name, so a husk with no shared schemes contributes a scheme
+    // named after a project that cannot be opened — which is how `Uwi0/Oakane`
+    // got `IOS_SCHEME: iosApp` as well as `IOS_PROJECT_PATH: iosApp.xcodeproj`.
+    const entries = xcodeContainersIn(root);
     for (const entry of entries) {
         if (!entry.endsWith(".xcodeproj"))
             continue;

package/dist/src/commands/ios-scheme-ranking.test.js

@@ -30,6 +30,11 @@ afterEach(() => {
 function scheme(project, name, { runnable, testable, appExtension }) {
     const dir = join(root, `${project}.xcodeproj`, "xcshareddata", "xcschemes");
     mkdirSync(dir, { recursive: true });
+    // A `.xcodeproj` is its `project.pbxproj`; without one Xcode refuses to open
+    // it and the scanners now skip it, so a fixture that omits it is describing
+    // a directory that cannot exist outside a test. Content is irrelevant here —
+    // the scheme XML is what the ranking reads — but it has to be there.
+    writeFileSync(join(root, `${project}.xcodeproj`, "project.pbxproj"), "// !$*UTF8*$!\n");
     writeFileSync(join(dir, `${name}.xcscheme`), `<?xml version="1.0" encoding="UTF-8"?>
 <Scheme LastUpgradeVersion = "1600"${appExtension ? `\n   wasCreatedForAppExtension = "YES"` : ""} version = "1.7">
    <TestAction buildConfiguration = "Debug">

package/dist/src/shared/detect-project.d.ts

@@ -1,5 +1,37 @@
 export type MobileProjectType = "android" | "ios" | "kmm";
 declare function isDirectory(path: string): boolean;
+/**
+ * True when a path that is *named* like an Xcode container actually is one.
+ *
+ * **The** predicate — every question of the form "is this `.xcodeproj` a
+ * project" goes through here, and nothing else in cibuild joins a directory
+ * name to "there is a project there".
+ *
+ * A `.xcodeproj` is a directory whose whole content is `project.pbxproj`;
+ * without it `xcodebuild` refuses to open the project at all — "missing its
+ * project.pbxproj file". A `.xcworkspace` is `contents.xcworkspacedata` in
+ * the same way. Anything else ending in those suffixes is a directory with a
+ * suggestive name, and offering one is offering something Xcode would reject.
+ *
+ * `Uwi0/Oakane` is the row that found it. Its `iosApp/` ships two: a tracked
+ * `iosApp.xcodeproj` holding nothing but `project.xcworkspace/`, and the real
+ * `oakane.xcodeproj` beside it with a 20 217-byte `project.pbxproj`. The husk
+ * carries the name the KMM wizard gives, so the conventional name outranked
+ * the project that exists — and it supplied BOTH `IOS_PROJECT_PATH` and, via
+ * the scheme scan's project-name fallback, `IOS_SCHEME`. The build reached
+ * step 9 and died on "Unable to read project 'iosApp.xcodeproj'".
+ *
+ * This is the iOS twin of the Gradle module scan once treating "a directory
+ * holding a file called build.gradle" as a module: wrong in the same
+ * direction, and fixed the same way — one reader, used by everyone.
+ *
+ * The `.pbxproj` is deliberately NOT parsed. Its existence and non-emptiness
+ * is the whole question; a shared `.xcscheme` remains the oracle for what a
+ * project builds.
+ */
+export declare function isXcodeContainer(path: string): boolean;
+/** The entries of `dir` that are real Xcode containers, in `readdir` order. */
+export declare function xcodeContainersIn(dir: string): string[];
 /**
  * Detects whether the given directory is the root of an Android, iOS, or
  * KMM project. Returns the detected project type, or null if none match.

package/dist/src/shared/detect-project.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"detect-project.d.ts","sourceRoot":"","sources":["../../../src/shared/detect-project.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,KAAK,GAAG,KAAK,CAAC;AAoB1D,iBAAS,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAM1C;AA+ED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CAiC7E;AAED,oEAAoE;AACpE,OAAO,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"detect-project.d.ts","sourceRoot":"","sources":["../../../src/shared/detect-project.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,KAAK,GAAG,KAAK,CAAC;AAoB1D,iBAAS,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAM1C;AAUD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAYtD;AAED,+EAA+E;AAC/E,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAYvD;AAuED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CA4B7E;AAED,oEAAoE;AACpE,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/src/shared/detect-project.js

@@ -33,6 +33,62 @@ function readOrNull(path) {
         return null;
     }
 }
+/**
+ * True when a path that is *named* like an Xcode container actually is one.
+ *
+ * **The** predicate — every question of the form "is this `.xcodeproj` a
+ * project" goes through here, and nothing else in cibuild joins a directory
+ * name to "there is a project there".
+ *
+ * A `.xcodeproj` is a directory whose whole content is `project.pbxproj`;
+ * without it `xcodebuild` refuses to open the project at all — "missing its
+ * project.pbxproj file". A `.xcworkspace` is `contents.xcworkspacedata` in
+ * the same way. Anything else ending in those suffixes is a directory with a
+ * suggestive name, and offering one is offering something Xcode would reject.
+ *
+ * `Uwi0/Oakane` is the row that found it. Its `iosApp/` ships two: a tracked
+ * `iosApp.xcodeproj` holding nothing but `project.xcworkspace/`, and the real
+ * `oakane.xcodeproj` beside it with a 20 217-byte `project.pbxproj`. The husk
+ * carries the name the KMM wizard gives, so the conventional name outranked
+ * the project that exists — and it supplied BOTH `IOS_PROJECT_PATH` and, via
+ * the scheme scan's project-name fallback, `IOS_SCHEME`. The build reached
+ * step 9 and died on "Unable to read project 'iosApp.xcodeproj'".
+ *
+ * This is the iOS twin of the Gradle module scan once treating "a directory
+ * holding a file called build.gradle" as a module: wrong in the same
+ * direction, and fixed the same way — one reader, used by everyone.
+ *
+ * The `.pbxproj` is deliberately NOT parsed. Its existence and non-emptiness
+ * is the whole question; a shared `.xcscheme` remains the oracle for what a
+ * project builds.
+ */
+export function isXcodeContainer(path) {
+    const manifest = path.endsWith(".xcworkspace")
+        ? "contents.xcworkspacedata"
+        : path.endsWith(".xcodeproj")
+            ? "project.pbxproj"
+            : null;
+    if (manifest === null)
+        return false;
+    try {
+        return statSync(resolve(path, manifest)).size > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/** The entries of `dir` that are real Xcode containers, in `readdir` order. */
+export function xcodeContainersIn(dir) {
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    return entries.filter((e) => (e.endsWith(".xcodeproj") || e.endsWith(".xcworkspace")) &&
+        isXcodeContainer(resolve(dir, e)));
+}
 /** True when this directory holds something an Apple build reads. */
 function holdsAppleConsumer(dir) {
     let entries;
@@ -42,7 +98,7 @@ function holdsAppleConsumer(dir) {
     catch {
         return false;
     }
-    if (entries.some((e) => e.endsWith(".xcodeproj") || e.endsWith(".xcworkspace"))) {
+    if (xcodeContainersIn(dir).length > 0) {
         return true;
     }
     if (entries.includes("Podfile"))
@@ -144,15 +200,11 @@ export function detectMobileProjectRoot(dir) {
     const iosFileIndicators = ["Podfile"];
     const hasIosFile = iosFileIndicators.some((f) => existsSync(resolve(dir, f)));
     if (!hasIosFile) {
-        try {
-            const entries = readdirSync(dir);
-            const hasXcodeDir = entries.some((e) => e.endsWith(".xcodeproj") || e.endsWith(".xcworkspace"));
-            if (hasXcodeDir)
-                return "ios";
-        }
-        catch {
-            // Unreadable directory — fall through.
-        }
+        // A husk — a directory named `*.xcodeproj` with no `project.pbxproj` —
+        // does not make this an iOS project root. Saying `ios` on the strength of
+        // one writes a pipeline aimed at something xcodebuild cannot open.
+        if (xcodeContainersIn(dir).length > 0)
+            return "ios";
     }
     else {
         return "ios";

package/dist/src/shared/xcode-container.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=xcode-container.test.d.ts.map

package/dist/src/shared/xcode-container.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xcode-container.test.d.ts","sourceRoot":"","sources":["../../../src/shared/xcode-container.test.ts"],"names":[],"mappings":""}

package/dist/src/shared/xcode-container.test.js

@@ -0,0 +1,123 @@
+/**
+ * A `.xcodeproj` with no `project.pbxproj` is not a project.
+ *
+ * `Uwi0/Oakane` is the row. Its `iosApp/` ships two Xcode projects: a tracked
+ * `iosApp.xcodeproj` holding nothing but `project.xcworkspace/`, and the real
+ * `oakane.xcodeproj` beside it. The scan chose the husk — `iosApp` is the name
+ * the KMM wizard gives, so the conventional name outranked the project that
+ * exists — and the build died at step 9 on
+ *
+ *   xcodebuild: error: Unable to read project 'iosApp.xcodeproj' …
+ *     Reason: … missing its project.pbxproj file.
+ *
+ * The husk supplied `IOS_SCHEME` too: with no shared schemes anywhere in that
+ * repository, `detectSchemes` falls back to each project's own directory name,
+ * so the husk contributed the scheme `iosApp` as well as the project path.
+ *
+ * This is the iOS twin of the Gradle module scan once treating "a directory
+ * holding a file called build.gradle" as a module, and it is fixed the same
+ * way: one reader, used by everyone.
+ */
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { isXcodeContainer, xcodeContainersIn, detectMobileProjectRoot } from "./detect-project.js";
+import { scanIosProject } from "../commands/ios-scanner.js";
+let root;
+beforeEach(() => {
+    root = mkdtempSync(join(tmpdir(), "cibuild-husk-"));
+});
+afterEach(() => {
+    rmSync(root, { recursive: true, force: true });
+});
+/** A project Xcode could open. */
+function project(name) {
+    mkdirSync(join(root, `${name}.xcodeproj`), { recursive: true });
+    writeFileSync(join(root, `${name}.xcodeproj`, "project.pbxproj"), "// !$*UTF8*$!\n");
+}
+/** Oakane's shape: the name, the inner workspace, and no project at all. */
+function husk(name) {
+    mkdirSync(join(root, `${name}.xcodeproj`, "project.xcworkspace"), { recursive: true });
+    writeFileSync(join(root, `${name}.xcodeproj`, "project.xcworkspace", "contents.xcworkspacedata"), '<?xml version="1.0" encoding="UTF-8"?>\n<Workspace version = "1.0"></Workspace>\n');
+}
+function workspace(name) {
+    mkdirSync(join(root, `${name}.xcworkspace`), { recursive: true });
+    writeFileSync(join(root, `${name}.xcworkspace`, "contents.xcworkspacedata"), '<?xml version="1.0" encoding="UTF-8"?>\n<Workspace version = "1.0"></Workspace>\n');
+}
+describe("isXcodeContainer", () => {
+    test("a project with a project.pbxproj is one", () => {
+        project("Real");
+        expect(isXcodeContainer(join(root, "Real.xcodeproj"))).toBe(true);
+    });
+    test("a project with no project.pbxproj is not", () => {
+        husk("iosApp");
+        expect(isXcodeContainer(join(root, "iosApp.xcodeproj"))).toBe(false);
+    });
+    test("an empty project.pbxproj is not a project either", () => {
+        mkdirSync(join(root, "Empty.xcodeproj"), { recursive: true });
+        writeFileSync(join(root, "Empty.xcodeproj", "project.pbxproj"), "");
+        expect(isXcodeContainer(join(root, "Empty.xcodeproj"))).toBe(false);
+    });
+    test("a workspace needs its contents.xcworkspacedata", () => {
+        workspace("Real");
+        mkdirSync(join(root, "Husk.xcworkspace"), { recursive: true });
+        expect(isXcodeContainer(join(root, "Real.xcworkspace"))).toBe(true);
+        expect(isXcodeContainer(join(root, "Husk.xcworkspace"))).toBe(false);
+    });
+    test("a path that is not named like a container is never one", () => {
+        mkdirSync(join(root, "Sources"), { recursive: true });
+        expect(isXcodeContainer(join(root, "Sources"))).toBe(false);
+        expect(isXcodeContainer(join(root, "does-not-exist"))).toBe(false);
+    });
+});
+describe("xcodeContainersIn", () => {
+    test("keeps the real projects and drops the husks", () => {
+        husk("iosApp");
+        project("oakane");
+        expect(xcodeContainersIn(root)).toEqual(["oakane.xcodeproj"]);
+    });
+    test("an unreadable directory is empty, not a throw", () => {
+        expect(xcodeContainersIn(join(root, "nowhere"))).toEqual([]);
+    });
+});
+describe("detectMobileProjectRoot", () => {
+    test("a husk alone is not an iOS project root", () => {
+        husk("iosApp");
+        expect(detectMobileProjectRoot(root)).toBeNull();
+    });
+    test("a real project beside a husk still is", () => {
+        husk("iosApp");
+        project("oakane");
+        expect(detectMobileProjectRoot(root)).toBe("ios");
+    });
+});
+describe("scanIosProject", () => {
+    test("Oakane's shape resolves the project that exists, and its scheme", async () => {
+        husk("iosApp");
+        project("oakane");
+        const scan = await scanIosProject(root);
+        expect(scan.projectPath).toBe("oakane.xcodeproj");
+        // No shared schemes anywhere, so each project falls back to its own name —
+        // and only one of them is a project.
+        expect(scan.detectedSchemes).toEqual(["oakane"]);
+    });
+    test("a repository whose only project is a husk resolves nothing", async () => {
+        husk("iosApp");
+        const scan = await scanIosProject(root);
+        expect(scan.projectPath).toBe("");
+        expect(scan.detectedSchemes).toEqual([]);
+    });
+    test("a single valid project is unchanged", async () => {
+        project("Contributions");
+        const scan = await scanIosProject(root);
+        expect(scan.projectPath).toBe("Contributions.xcodeproj");
+        expect(scan.detectedSchemes).toEqual(["Contributions"]);
+    });
+    test("a workspace still outranks a project beside it", async () => {
+        project("QiniuSDK");
+        workspace("QiniuSDK");
+        const scan = await scanIosProject(root);
+        expect(scan.projectPath).toBe("QiniuSDK.xcworkspace");
+    });
+});
+//# sourceMappingURL=xcode-container.test.js.map

package/dist/src/yaml/steps/xcode-app-product.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Which built `.app` belongs to the scheme that was built.
+ *
+ * A simulator build leaves every application bundle its graph produced under
+ * `DerivedData/Build/Products/<configuration>-<platform>/`, and a scheme that
+ * builds a watchOS or tvOS companion alongside the app produces two. Taking
+ * whichever one a directory scan reaches first is a coin toss, and it lands the
+ * wrong way often enough to matter: a project whose scheme builds both an iOS
+ * app and a watch companion exported the 588 KB watch bundle as the app under
+ * test. The build was green, the artifact manifest was non-empty, and the
+ * thing a user downloaded could not be installed on the device they built for.
+ * That is worse than delivering nothing, because nothing is visibly wrong and
+ * a plausible wrong answer is not.
+ *
+ * The scheme already knows. A shared `.xcscheme` lists its build entries with a
+ * `BuildableName` whose extension IS the product type, and `buildForRunning`
+ * separates what the scheme builds from what it merely references — a scheme
+ * may list several `.app` entries it does not build, so "mentions an app" is
+ * not the question and a check that asked it would pick just as badly.
+ *
+ * Where the scheme gives no answer this falls back rather than failing. A
+ * project with no shared scheme at all is ordinary — plenty of them never
+ * commit one — and those builds work. Absence of evidence is not evidence, so
+ * the destination's own platform directory decides, and failing to resolve an
+ * app is left to the caller's existing guard.
+ *
+ * The whole resolver runs on the machine that did the build, against the
+ * products that build actually produced, so it needs nothing from the step
+ * generator but the scheme name and the destination.
+ */
+/** A built application bundle, as found under `Build/Products`. */
+export interface BuiltApp {
+    /** The `<configuration>-<platform>` directory, or `''` directly under Products. */
+    platform: string;
+    /** The bundle's own name, e.g. `MyApp.app`. */
+    name: string;
+    /** Absolute path to the bundle. */
+    path: string;
+}
+/**
+ * The SDK suffix the Products directory carries for a given destination.
+ *
+ * `-destination 'generic/platform=iOS Simulator'` builds into
+ * `Debug-iphonesimulator`; the watchOS and tvOS spellings are the ones that
+ * matter here, because a companion target is exactly what produces the second
+ * bundle this resolver exists to skip past.
+ */
+export declare function platformSuffixForDestination(destination: string): string;
+/**
+ * The application bundles a scheme's build action actually builds.
+ *
+ * `buildForRunning="NO"` entries are listed and not built. A scheme can carry
+ * three `.app` entries that are API-compatibility testers in other containers
+ * beside the one framework it really produces, so the attribute is the whole
+ * filter rather than a refinement of one.
+ *
+ * Returns an empty list for a file that cannot be read or carries no build
+ * action — no evidence, which the caller must not read as "builds no app".
+ */
+export declare function runnableAppProducts(schemeXml: string | null): string[];
+/**
+ * The bundle to export, given everything that was built and what the scheme
+ * says it builds.
+ *
+ * In order: the scheme's own product on the destination's platform, the
+ * scheme's own product anywhere, anything on the destination's platform,
+ * anything at all. The last two are the no-shared-scheme path, and they are
+ * what keeps a project that never committed a scheme building exactly as it
+ * did before.
+ */
+export declare function chooseAppProduct(apps: BuiltApp[], schemeProducts: string[], destination: string): BuiltApp | null;
+/**
+ * The resolver as it runs on the build machine: dependency-free CommonJS,
+ * written to a temp file and invoked with
+ * `node <file> <productsDir> <projectPath> <scheme> <destination>`.
+ *
+ * It prints the chosen bundle's path and nothing else, and exits non-zero with
+ * no output when it cannot choose — which is the signal for the caller's
+ * existing scan to take over, so a machine without a usable node is no worse
+ * off than before this existed.
+ *
+ * Kept as source text rather than bundled because the step ships a shell
+ * script, not a module graph. The three functions above are the same rules in
+ * testable form, and `xcode-app-product.test.ts` holds them to each other.
+ *
+ * Must contain no backtick and no dollar-brace: it is emitted into a bash
+ * heredoc, and it is a TypeScript template literal on the way there.
+ */
+export declare const APP_PRODUCT_RESOLVER_SOURCE: string;
+//# sourceMappingURL=xcode-app-product.d.ts.map

package/dist/src/yaml/steps/xcode-app-product.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xcode-app-product.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/xcode-app-product.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,mEAAmE;AACnE,MAAM,WAAW,QAAQ;IACvB,mFAAmF;IACnF,QAAQ,EAAE,MAAM,CAAC;IACjB,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAMxE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,EAAE,CAatE;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,QAAQ,EAAE,EAChB,cAAc,EAAE,MAAM,EAAE,EACxB,WAAW,EAAE,MAAM,GAClB,QAAQ,GAAG,IAAI,CAOjB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,2BAA2B,EAAE,MAqIzC,CAAC"}