@mpgd/cli 0.35.0 → 0.36.0

package/dist/deploy-process.js

@@ -0,0 +1,197 @@
+import { spawn, spawnSync } from 'node:child_process';
+const reasonLabels = {
+    abort: 'aborted',
+    exit: 'failed',
+    spawn: 'could not start',
+    timeout: 'timed out',
+};
+export class ReleaseProcessError extends Error {
+    reason;
+    output;
+    exitCode;
+    constructor(reason, output, exitCode) {
+        super(`Release process ${reasonLabels[reason]}${output === '' ? '.' : `:\n${output}`}`);
+        this.name = 'ReleaseProcessError';
+        this.reason = reason;
+        this.output = output;
+        if (exitCode !== undefined) {
+            this.exitCode = exitCode;
+        }
+    }
+}
+const defaultMaxOutputBytes = 256 * 1024;
+const sensitiveEnvironmentKey = /(?:^|_)(?:PASSWORD|TOKEN|SECRET|CREDENTIAL|PRIVATE_KEY|API_KEY)(?:_|$)|^GIT_CONFIG_VALUE_\d+$/iu;
+/** Execute a release step without streaming unredacted child output to logs. */
+export async function runReleaseProcess(input) {
+    if (!Number.isSafeInteger(input.timeoutMs) || input.timeoutMs < 1) {
+        throw new Error('Release process timeoutMs must be a positive integer.');
+    }
+    const outputLimit = input.maxOutputBytes ?? defaultMaxOutputBytes;
+    if (!Number.isSafeInteger(outputLimit) || outputLimit < 1) {
+        throw new Error('Release process maxOutputBytes must be a positive integer.');
+    }
+    if (input.signal?.aborted) {
+        throw new ReleaseProcessError('abort', '');
+    }
+    const environment = input.environment ?? process.env;
+    const secrets = [
+        input.stdin ?? '',
+        ...(input.secretValues ?? []),
+        ...Object.entries(environment)
+            .filter(([key]) => sensitiveEnvironmentKey.test(key))
+            .map(([, value]) => value ?? ''),
+    ].filter((value) => value.length > 0);
+    const launch = resolveReleaseCommand(input.command, input.args, environment);
+    return new Promise((resolve, reject) => {
+        let child;
+        try {
+            child = spawn(launch.command, [...launch.args], {
+                cwd: input.cwd,
+                env: environment,
+                stdio: [input.stdin === undefined ? 'ignore' : 'pipe', 'pipe', 'pipe'],
+                detached: process.platform !== 'win32',
+                shell: false,
+            });
+        }
+        catch {
+            reject(new ReleaseProcessError('spawn', ''));
+            return;
+        }
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        let capturedBytes = 0;
+        let truncated = false;
+        let stdoutTruncated = false;
+        let stderrTruncated = false;
+        let stopReason;
+        let settled = false;
+        let escalation;
+        if (input.stdin !== undefined) {
+            child.stdin?.on('error', () => {
+                // The child may exit before consuming a short secret input.
+            });
+            child.stdin?.end(input.stdin);
+        }
+        const capture = (stream, chunk) => {
+            const available = Math.max(0, outputLimit - capturedBytes);
+            if (available > 0) {
+                const selected = chunk.subarray(0, available);
+                (stream === 'stdout' ? stdoutChunks : stderrChunks).push(selected);
+                capturedBytes += selected.length;
+            }
+            if (chunk.length > available) {
+                truncated = true;
+                if (stream === 'stdout') {
+                    stdoutTruncated = true;
+                }
+                else {
+                    stderrTruncated = true;
+                }
+            }
+        };
+        child.stdout?.on('data', (chunk) => capture('stdout', chunk));
+        child.stderr?.on('data', (chunk) => capture('stderr', chunk));
+        const renderOutput = () => {
+            const longestSecretBytes = secrets.reduce((longest, secret) => Math.max(longest, Buffer.byteLength(secret)), 0);
+            const renderStream = (chunks, wasTruncated) => {
+                const captured = Buffer.concat(chunks);
+                const safeBytes = wasTruncated
+                    ? captured.subarray(0, Math.max(0, captured.length - longestSecretBytes))
+                    : captured;
+                let output = safeBytes.toString('utf8');
+                for (const secret of [...new Set(secrets)].sort((a, b) => b.length - a.length)) {
+                    output = output.replaceAll(secret, '[REDACTED]');
+                }
+                return output;
+            };
+            const output = [
+                renderStream(stdoutChunks, stdoutTruncated),
+                renderStream(stderrChunks, stderrTruncated),
+            ].filter((part) => part !== '').join('\n');
+            return truncated ? `${output}\n[output truncated]` : output;
+        };
+        const terminate = (reason) => {
+            if (settled || stopReason !== undefined) {
+                return;
+            }
+            stopReason = reason;
+            killReleaseProcess(child.pid, 'SIGTERM');
+            escalation = setTimeout(() => killReleaseProcess(child.pid, 'SIGKILL'), 2_000);
+            escalation.unref();
+        };
+        const onAbort = () => terminate('abort');
+        input.signal?.addEventListener('abort', onAbort, { once: true });
+        if (input.signal?.aborted) {
+            onAbort();
+        }
+        const timeout = setTimeout(() => terminate('timeout'), input.timeoutMs);
+        timeout.unref();
+        const cleanup = () => {
+            settled = true;
+            clearTimeout(timeout);
+            if (escalation !== undefined) {
+                clearTimeout(escalation);
+            }
+            input.signal?.removeEventListener('abort', onAbort);
+        };
+        child.once('error', () => {
+            if (settled) {
+                return;
+            }
+            cleanup();
+            reject(new ReleaseProcessError('spawn', renderOutput()));
+        });
+        child.once('close', (code) => {
+            if (settled) {
+                return;
+            }
+            if (stopReason !== undefined) {
+                // The direct child may exit while a build tool it spawned is still alive.
+                killReleaseProcess(child.pid, 'SIGKILL');
+            }
+            cleanup();
+            const output = renderOutput();
+            if (stopReason !== undefined) {
+                reject(new ReleaseProcessError(stopReason, output));
+            }
+            else if (code !== 0) {
+                reject(new ReleaseProcessError('exit', output, code ?? undefined));
+            }
+            else {
+                resolve({
+                    output,
+                    truncated,
+                    ...(input.captureMachineStdout === true
+                        ? { machineStdout: Buffer.concat(stdoutChunks).toString('utf8') }
+                        : {}),
+                });
+            }
+        });
+    });
+}
+function resolveReleaseCommand(command, args, environment) {
+    if (process.platform !== 'win32' || command !== 'pnpm') {
+        return { command, args };
+    }
+    const pnpmScript = environment.npm_execpath;
+    if (pnpmScript === undefined || !/\.[cm]?js$/iu.test(pnpmScript)) {
+        throw new Error('Windows release steps require a pnpm JavaScript entrypoint. Run via pnpm.');
+    }
+    return { command: process.execPath, args: [pnpmScript, ...args] };
+}
+function killReleaseProcess(pid, signal) {
+    if (pid === undefined) {
+        return;
+    }
+    try {
+        if (process.platform === 'win32') {
+            spawnSync('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore' });
+        }
+        else {
+            process.kill(-pid, signal);
+        }
+    }
+    catch {
+        // The process may have exited between a timeout and termination.
+    }
+}

package/dist/index.d.ts

@@ -1,5 +1,13 @@
 export { renderGameAcceptanceMarkdown, resolveGameAcceptanceReleaseManifestFile, runGameAcceptance, defaultGameAcceptanceCommandTimeoutMs, maximumGameplayE2EReportBytes, type GameAcceptanceCommandResult, type GameAcceptanceCommandRunner, type GameAcceptanceReport, type GameAcceptanceStatus, type GameAcceptanceStep, type GameAcceptanceStepResult, type GameAcceptanceStepStatus, type RunGameAcceptanceInput, type RunGameAcceptanceResult, } from './game-acceptance.js';
 export { applyCapacitorShellStarter, materializeCapacitorShellStarter, planCapacitorShellStarter, type CapacitorShellCommandRunner, type CapacitorShellStarterInput, type CapacitorShellStarterPlan, } from './capacitor-shell-starter.js';
+export { ReleaseProcessError, runReleaseProcess, type ReleaseProcessInput, type ReleaseProcessResult, } from './deploy-process.js';
+export { installPinnedReleaseDependencies, pinNativeDeploymentPlan, preparePinnedReleaseWorkspace, runPinnedNativeBuild, withPinnedReleaseWorkspace, type PinnedNativeBuildResult, type PinnedReleaseInput, type PinnedReleaseWorkspace, } from './release-workspace.js';
+export { withAndroidUploadSigningSession, type AndroidUploadSigningInput, } from './android-signing-session.js';
+export { checkpointNativeSubmission, readNativeReleaseStatus, reclaimNativeSubmission, releaseNativeSubmissionLease, recordNativeReleaseBuild, reserveNativeRelease, type ImmutableNativeBuildRecord, type NativeReleaseStatus, type NativeReleaseReservation, type NativeReleaseReservationInput, type NativeSubmissionCheckpoint, type NativeSubmissionStatus, type RecordNativeBuildInput, } from './release-state.js';
+export { runNativeDeployment, readStoreCredential, type RunNativeDeploymentInput, } from './native-deploy-run.js';
+export { submitRecordedNativeTarget, type NativeStoreCredential, type SubmitRecordedNativeTargetInput, } from './native-deploy-submission.js';
+export { PlaySubmissionUncertainError, submitVerifiedAndroidBundle, type PlayInternalSubmissionInput, type PlayInternalSubmissionResult, } from './play-internal-submission.js';
+export { IosSubmissionUncertainError, submitVerifiedIosBuild, type IosTestFlightStatus, type IosTestFlightSubmissionInput, type IosTestFlightSubmissionResult, } from './testflight-submission.js';
 export { createBrowserGameplayE2EDriver, type BrowserGameplayE2EInspectInput, type BrowserGameplayE2EPage, type BrowserGameplayE2EScreenshotOptions, type BrowserGameplayE2EViewport, type CreateBrowserGameplayE2EDriverInput, } from './browser-gameplay-e2e.js';
 export { collectGameplayE2EPathEvidence, defaultGameplayE2EReportFile, maximumGameplayE2EStates, parseGameplayE2EPlan, readGameplayE2EPlan, renderGameplayE2EMarkdown, resolveGameplayE2EReportFile, runGameplayE2E, type GameplayE2EAction, type GameplayE2EActionResult, type GameplayE2EDriver, type GameplayE2EHashLimits, type GameplayE2EInputAction, type GameplayE2EObservation, type GameplayE2EPauseResumeAction, type GameplayE2EPathEvidence, type GameplayE2EPlan, type GameplayE2EReport, type GameplayE2EResultStatus, type GameplayE2EState, type GameplayE2EStateResult, type GameplayE2EStatus, type RunGameplayE2EInput, type RunGameplayE2EResult, } from './gameplay-e2e.js';
 export { cloudflarePagesDeploymentProfiles, hostedPwaDeploymentHosts, isSupportedHostedPwaProfile, verifyHostedPwaDeployment, type CloudflarePagesDeploymentProfile, type HostedPwaDeploymentHost, type HostedPwaDeploymentVerification, type VerifyHostedPwaDeploymentInput, } from './hosted-pwa-deployment.js';