@mpgd/cli 0.33.1 → 0.34.0

package/dist/asset-pack-verify.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { constants } from 'node:fs';
 import { lstat, open, opendir, realpath, stat } from 'node:fs/promises';
 import { isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { verifyZipV1Archive, ZipDecodeError, } from '@mpgd/phaser-assets/archive-validation';
@@ -6,6 +7,7 @@ import { defaultArchiveWorkerLimits } from '@mpgd/phaser-assets/archives';
 import { validatePhaserPackDeliveryManifest, } from '@mpgd/phaser-assets/pack-format';
 const DEFAULT_MANIFEST_BYTE_CAP = 32 * 1024 * 1024;
 const DEFAULT_VERIFY_TIMEOUT_MS = 120_000;
+const FIFO_WRITER_GRACE_MS = 1000;
 /** The watchdog arms one millisecond after the deadline. Leave one
  * millisecond of headroom so the largest accepted timeout plus that offset
  * still fits the platform timer range instead of clamping to 1 ms. */
@@ -255,10 +257,10 @@ const inventoryRoot = async (root, deadline) => {
     return { files, bytes, largest, truncated };
 };
 const readManifestCapped = async (manifestPath, cap, deadline) => {
-    // Open through the deadline: a FIFO with no writer blocks inside
-    // open(2) before any stream event exists, and destroying a stream
-    // cannot cancel that pending open.
-    const handle = await deadline.race(open(resolve(manifestPath), 'r'));
+    // Open through the deadline. POSIX O_NONBLOCK keeps FIFO open/read calls
+    // bounded; Windows retains the stream fallback under the same deadline.
+    const flags = process.platform === 'win32' ? 'r' : constants.O_RDONLY | constants.O_NONBLOCK;
+    const handle = await deadline.race(open(resolve(manifestPath), flags));
     const chunks = [];
     let received = 0;
     let stalled = false;
@@ -292,30 +294,85 @@ const readManifestCapped = async (manifestPath, cap, deadline) => {
                 throw new Error(`Delivery manifest changed while reading (expected ${expectedBytes} bytes, received more)`);
             }
         }
+        else if (process.platform !== 'win32') {
+            // A blocking FIFO read can remain pending after stream.destroy() on
+            // some Linux hosts. O_NONBLOCK bounds each read: EAGAIN means a writer
+            // is connected but has no data; a later zero-byte read is its EOF.
+            const buffer = Buffer.allocUnsafe(Math.min(STREAM_CHUNK_BYTES, cap + 1));
+            const isFifo = info.isFIFO();
+            // A writer can open and close between read polls without ever yielding
+            // EAGAIN. Bound the initial connection wait so that empty EOF cannot
+            // consume the default two-minute verification budget.
+            const writerGraceUntil = performance.now() + Math.min(FIFO_WRITER_GRACE_MS, deadline.remainingMs());
+            let writerObserved = false;
+            while (true) {
+                deadline.sample();
+                let bytesRead;
+                let wouldBlock = false;
+                try {
+                    ({ bytesRead } = await deadline.race(handle.read(buffer, 0, buffer.byteLength, null)));
+                }
+                catch (error) {
+                    if (typeof error !== 'object'
+                        || error === null
+                        || !('code' in error)
+                        || (error.code !== 'EAGAIN' && error.code !== 'EWOULDBLOCK')) {
+                        throw error;
+                    }
+                    writerObserved = true;
+                    wouldBlock = true;
+                    bytesRead = 0;
+                }
+                if (bytesRead === 0) {
+                    // Other sources have ordinary EOF. An unconnected FIFO waits only
+                    // for its bounded startup grace; an observed writer has hung up.
+                    if (!wouldBlock
+                        && (!isFifo || writerObserved || performance.now() >= writerGraceUntil)) {
+                        break;
+                    }
+                    const waitMs = Math.min(10, Math.max(1, deadline.remainingMs()));
+                    await deadline.race(new Promise((resume) => setTimeout(resume, waitMs)));
+                    continue;
+                }
+                writerObserved = true;
+                received += bytesRead;
+                if (received > cap) {
+                    throw new Error(`Delivery manifest exceeds ${cap} bytes`);
+                }
+                chunks.push(Buffer.from(buffer.subarray(0, bytesRead)));
+                deadline.sample();
+            }
+        }
         else {
-            // FIFOs and other non-regular sources retain the stream watchdog: a
-            // pending read must be destroyed after the deadline so a direct
-            // FileHandle.read cannot leave the smoke process alive behind a
-            // rejected race.
+            // Windows non-regular sources retain the stream watchdog. A pending
+            // read must be destroyed at the deadline, then the race can return
+            // without waiting for that read to settle.
             const stream = handle.createReadStream({
                 highWaterMark: STREAM_CHUNK_BYTES,
                 autoClose: false,
             });
             const timer = deadline.armStream(stream);
             try {
-                for await (const chunk of stream) {
-                    const view = chunk;
-                    received += view.byteLength;
-                    if (received > cap) {
-                        stream.destroy();
-                        throw new Error(`Delivery manifest exceeds ${cap} bytes`);
+                await deadline.race((async () => {
+                    for await (const chunk of stream) {
+                        const view = chunk;
+                        received += view.byteLength;
+                        if (received > cap) {
+                            stream.destroy();
+                            throw new Error(`Delivery manifest exceeds ${cap} bytes`);
+                        }
+                        chunks.push(Buffer.from(view));
+                        deadline.sample();
                     }
-                    chunks.push(Buffer.from(view));
-                    deadline.sample();
-                }
+                })());
             }
             finally {
+                // Destroy may not wake a pending FIFO read until its writer closes.
+                // The raced deadline returns the report without waiting for that read.
                 clearTimeout(timer);
+                if (!stream.destroyed) {
+                    stream.destroy();
+                }
             }
         }
     }

package/dist/capacitor-shell-starter.d.ts

@@ -0,0 +1,40 @@
+interface PlannedFile {
+  readonly path: string;
+  readonly content: string;
+}
+export interface CapacitorShellStarterInput {
+  readonly gameRoot: string;
+  readonly appId: string;
+  readonly displayName: string;
+  readonly iconSource?: string;
+  readonly backendUrl?: string;
+  /** Selection metadata only; a provider SDK is not installed or enabled here. */
+  readonly providerIds?: readonly string[];
+}
+export interface CapacitorShellStarterPlan {
+  readonly gameRoot: string;
+  readonly input: CapacitorShellStarterInput;
+  readonly changedFiles: readonly string[];
+  readonly nativePlatformsToAdd: readonly ('android' | 'ios')[];
+  readonly files: readonly PlannedFile[];
+}
+/**
+* Produce the complete game-owned shell change list before writing anything.
+* Existing Android/iOS projects, signing files, and custom controllers are
+* never rewritten by this initializer.
+*/
+export declare function planCapacitorShellStarter(input: CapacitorShellStarterInput): CapacitorShellStarterPlan;
+export declare function applyCapacitorShellStarter(plan: CapacitorShellStarterPlan, installStagedFile?: (temporary: string, destination: string) => void): void;
+export interface CapacitorShellCommandRunner {
+  run(command: string, args: readonly string[], cwd: string): void;
+}
+/** Materialize only missing native projects after the non-destructive plan is applied. */
+export declare function materializeCapacitorShellStarter(plan: CapacitorShellStarterPlan, runner?: CapacitorShellCommandRunner): void;
+/** Fail closed when a Release plist hardcodes values independently of Xcode build settings. */
+export declare function assertIosReleasePlistIdentity(source: string): void;
+export declare function assertAndroidReleaseDisplayName(shellApp: string, expectedDisplayName: string): void;
+export declare function assertAndroidReleaseLauncherIntegrity(shellApp: string): void;
+export declare function assertIosReleaseDisplayName(shellApp: string, expectedDisplayName: string): void;
+export declare function assertIosArchiveScheme(shellApp: string): void;
+export declare function decodeAndroidStringResource(value: string): string;
+export {};