eoas 3.0.5 → 3.1.0

package/dist/lib/ora.js

@@ -2,101 +2,62 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ora = void 0;
 const tslib_1 = require("tslib");
-// This file is copied from eas-cli[https://github.com/expo/eas-cli] to ensure consistent user experience across the CLI.
+// Spinner drawn with the @clack/prompts spinner so it matches the CLI's
+// visual identity. Keeps the ora-like call surface the commands already use
+// (start/succeed/fail/warn/stop). In CI, non-TTY or debug runs the spinner
+// degrades to plain log lines so output stays deterministic.
+const clack = tslib_1.__importStar(require("@clack/prompts"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const getenv_1 = require("getenv");
-// eslint-disable-next-line
-const ora_1 = tslib_1.__importDefault(require("ora"));
 const log_1 = tslib_1.__importDefault(require("./log"));
-// eslint-disable-next-line no-console
-const logReal = console.log;
-// eslint-disable-next-line no-console
-const infoReal = console.info;
-// eslint-disable-next-line no-console
-const warnReal = console.warn;
-// eslint-disable-next-line no-console
-const errorReal = console.error;
 const isCi = (0, getenv_1.boolish)('CI', false);
-/**
- * A custom ora spinner that sends the stream to stdout in CI, or non-TTY, instead of stderr (the default).
- *
- * @param options
- * @returns
- */
 function ora(options) {
-    const inputOptions = typeof options === 'string' ? { text: options } : options ?? {};
     const disabled = log_1.default.isDebug || !process.stdin.isTTY || isCi;
-    const spinner = (0, ora_1.default)({
-        // Ensure our non-interactive mode emulates CI mode.
-        isEnabled: !disabled,
-        // In non-interactive mode, send the stream to stdout so it prevents looking like an error.
-        stream: disabled ? process.stdout : process.stderr,
-        ...inputOptions,
-    });
-    const oraStart = spinner.start.bind(spinner);
-    const oraStop = spinner.stop.bind(spinner);
-    const oraStopAndPersist = spinner.stopAndPersist.bind(spinner);
-    const logWrap = (method, args) => {
-        oraStop();
-        method(...args);
-        spinner.start();
-    };
-    const wrapNativeLogs = () => {
-        // eslint-disable-next-line no-console
-        console.log = (...args) => {
-            logWrap(logReal, args);
-        };
-        // eslint-disable-next-line no-console
-        console.info = (...args) => {
-            logWrap(infoReal, args);
-        };
-        // eslint-disable-next-line no-console
-        console.warn = (...args) => {
-            logWrap(warnReal, args);
-        };
-        // eslint-disable-next-line no-console
-        console.error = (...args) => {
-            logWrap(errorReal, args);
-        };
-    };
-    const resetNativeLogs = () => {
-        // eslint-disable-next-line no-console
-        console.log = logReal;
-        // eslint-disable-next-line no-console
-        console.info = infoReal;
-        // eslint-disable-next-line no-console
-        console.warn = warnReal;
-        // eslint-disable-next-line no-console
-        console.error = errorReal;
-    };
-    spinner.start = (text) => {
-        // wrapNativeLogs wraps calls to console so they always:
-        // 1. stop the spinner
-        // 2. log the message
-        // 3. start the spinner again
-        // Every restart of the spinner causes the spinner message to be logged again
-        // which makes logs look like
-        //
-        // - Exporting...
-        // [expo-cli] Starting Metro Bundler
-        // - Exporting...
-        // [expo-cli] Android Bundling complete 3492ms
-        // - Exporting...
-        //
-        // Skipping wrapping native logs removes the repeated interleaved "Exporting..." messages.
-        if (!disabled) {
-            wrapNativeLogs();
+    let text = typeof options === 'string' ? options : options?.text ?? '';
+    let active;
+    const finish = (message, code, fallback) => {
+        if (active) {
+            active.stop(message, code);
+            active = undefined;
+        }
+        else {
+            fallback(message);
         }
-        return oraStart(text);
-    };
-    spinner.stopAndPersist = (options) => {
-        const result = oraStopAndPersist(options);
-        resetNativeLogs();
-        return result;
     };
-    spinner.stop = () => {
-        const result = oraStop();
-        resetNativeLogs();
-        return result;
+    const spinner = {
+        start(nextText) {
+            text = nextText ?? text;
+            if (disabled) {
+                log_1.default.log(text);
+            }
+            else {
+                active = clack.spinner();
+                active.start(text);
+            }
+            return spinner;
+        },
+        succeed(nextText) {
+            finish(nextText ?? text, 0, message => {
+                log_1.default.succeed(message);
+            });
+            return spinner;
+        },
+        fail(nextText) {
+            finish(nextText ?? text, 2, message => {
+                log_1.default.fail(message);
+            });
+            return spinner;
+        },
+        warn(nextText) {
+            finish(chalk_1.default.yellow(nextText ?? text), 0, message => {
+                log_1.default.warn(message);
+            });
+            return spinner;
+        },
+        stop() {
+            finish(chalk_1.default.dim(text), 0, () => { });
+            return spinner;
+        },
     };
     return spinner;
 }

package/dist/lib/packageRunner.js

@@ -42,8 +42,9 @@ function resolvePackageRunner(explicit, projectDir) {
     }
     if (projectDir) {
         const detected = detectRunnerFromPackageJson(projectDir);
-        if (detected)
+        if (detected) {
             return detected;
+        }
     }
     return DEFAULT_PACKAGE_RUNNER;
 }

package/dist/lib/prompts.d.ts

@@ -10,4 +10,36 @@ export declare function selectAsync<T>(message: string, choices: ExpoChoice<T>[]
     warningMessageForDisabledEntries?: string;
 }): Promise<T>;
 export declare function toggleConfirmAsync(questions: prompts.PromptObject<any>, options?: Options): Promise<boolean>;
+/** Returned by the clack-based prompts below when the user asks to go back one step. */
+export declare const BACK: unique symbol;
+export declare const BACK_INPUT = "<";
+export type TextStepOptions = {
+    initial?: string;
+    /** Empty answers are allowed and become undefined. */
+    optional?: boolean;
+    secret?: boolean;
+    allowBack?: boolean;
+    validate?: (value: string) => true | string;
+};
+/**
+ * clack redraws break as soon as a prompt line wraps, so the message plus the
+ * suffix must stay well under a terminal width; keep messages short and never
+ * use clack placeholders (Tab types them into the buffer and a skipped answer
+ * renders them as if submitted).
+ */
+export declare function textStep(message: string, options?: TextStepOptions): Promise<string | undefined | typeof BACK>;
+export type SelectStepChoice<T> = {
+    title: string;
+    value: T;
+    description?: string;
+};
+export declare function selectStep<T>(message: string, choices: SelectStepChoice<T>[], options: {
+    allowBack: boolean;
+    initial?: T;
+}): Promise<T | typeof BACK>;
+export declare function yesNoStep(message: string, options: {
+    allowBack: boolean;
+    initial?: boolean;
+}): Promise<boolean | typeof BACK>;
+export declare function confirmStep(message: string, initial?: boolean): Promise<boolean>;
 export declare function pressAnyKeyToContinueAsync(): Promise<void>;

package/dist/lib/prompts.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pressAnyKeyToContinueAsync = exports.toggleConfirmAsync = exports.selectAsync = exports.confirmAsync = exports.promptAsync = void 0;
+exports.pressAnyKeyToContinueAsync = exports.confirmStep = exports.yesNoStep = exports.selectStep = exports.textStep = exports.BACK_INPUT = exports.BACK = exports.toggleConfirmAsync = exports.selectAsync = exports.confirmAsync = exports.promptAsync = void 0;
 const tslib_1 = require("tslib");
 // This file is copied from eas-cli[https://github.com/expo/eas-cli] to ensure consistent user experience across the CLI.
+const clack = tslib_1.__importStar(require("@clack/prompts"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const os_1 = require("os");
 const prompts_1 = tslib_1.__importDefault(require("prompts"));
 async function promptAsync(questions, options = {}) {
@@ -52,6 +54,89 @@ async function toggleConfirmAsync(questions, options) {
     return value ?? null;
 }
 exports.toggleConfirmAsync = toggleConfirmAsync;
+/** Returned by the clack-based prompts below when the user asks to go back one step. */
+exports.BACK = Symbol('back');
+exports.BACK_INPUT = '<';
+function ensureNotCancelled(value) {
+    if (clack.isCancel(value)) {
+        clack.cancel('Cancelled, nothing was written.');
+        process.exit(os_1.constants.signals.SIGINT + 128);
+    }
+    return value;
+}
+/**
+ * clack redraws break as soon as a prompt line wraps, so the message plus the
+ * suffix must stay well under a terminal width; keep messages short and never
+ * use clack placeholders (Tab types them into the buffer and a skipped answer
+ * renders them as if submitted).
+ */
+async function textStep(message, options = {}) {
+    const hints = [];
+    if (options.optional) {
+        hints.push('optional');
+    }
+    if (options.allowBack) {
+        hints.push(`${exports.BACK_INPUT} back`);
+    }
+    const suffix = hints.length > 0 ? ` ${chalk_1.default.dim(`(${hints.join(' · ')})`)}` : '';
+    const validate = (v) => {
+        const value = v ?? '';
+        if ((options.allowBack && value === exports.BACK_INPUT) || (options.optional && value === '')) {
+            return undefined;
+        }
+        if (!options.validate) {
+            return options.optional || value !== '' ? undefined : 'Cannot be empty';
+        }
+        const result = options.validate(value);
+        return result === true ? undefined : result;
+    };
+    const value = ensureNotCancelled(options.secret
+        ? await clack.password({ message: `${message}${suffix}`, validate })
+        : await clack.text({
+            message: `${message}${suffix}`,
+            initialValue: options.initial,
+            validate,
+        }));
+    const answer = (value ?? '').trim();
+    if (options.allowBack && answer === exports.BACK_INPUT) {
+        return exports.BACK;
+    }
+    return answer !== '' ? answer : undefined;
+}
+exports.textStep = textStep;
+// Selection happens on indices (clack's Option type does not resolve with an
+// open generic); -1 is the Back entry.
+async function selectStep(message, choices, options) {
+    const list = choices.map((choice, index) => ({
+        value: index,
+        label: choice.title,
+        hint: choice.description,
+    }));
+    if (options.allowBack) {
+        list.push({ value: -1, label: '← Back', hint: 'previous step' });
+    }
+    const initialIndex = options.initial === undefined
+        ? undefined
+        : choices.findIndex(choice => choice.value === options.initial);
+    const picked = ensureNotCancelled(await clack.select({
+        message,
+        options: list,
+        initialValue: initialIndex !== undefined && initialIndex >= 0 ? initialIndex : undefined,
+    }));
+    return picked === -1 ? exports.BACK : choices[picked].value;
+}
+exports.selectStep = selectStep;
+async function yesNoStep(message, options) {
+    return await selectStep(message, [
+        { title: 'Yes', value: true },
+        { title: 'No', value: false },
+    ], { allowBack: options.allowBack, initial: options.initial ?? false });
+}
+exports.yesNoStep = yesNoStep;
+async function confirmStep(message, initial = false) {
+    return ensureNotCancelled(await clack.confirm({ message, initialValue: initial }));
+}
+exports.confirmStep = confirmStep;
 async function pressAnyKeyToContinueAsync() {
     process.stdin.setRawMode(true);
     process.stdin.resume();

package/dist/lib/serverConfig/choices.d.ts

@@ -0,0 +1,62 @@
+export type Storage = 'aws-s3' | 's3-compatible' | 'gcs' | 'azure';
+export type S3Provider = 'cloudflare-r2' | 'minio' | 'digitalocean-spaces' | 'supabase';
+export type Delivery = 'cloudfront' | 'presigned' | 'through-server' | 'generic-cdn';
+export type MasterKeySource = 'environment' | 'aws-secrets-manager';
+export type AwsAuth = 'iam-role' | 'access-keys';
+export type CacheMode = 'redis' | 'redis-sentinel' | 'local';
+export type Replicas = 'single' | 'multi';
+export type Deployment = 'docker' | 'binary' | 'helm';
+export type GeoipStrategy = 'proxy-headers' | 'maxmind';
+export type ServerChoices = {
+    baseUrl?: string;
+    jwtSecret?: string;
+    dbUrl?: string;
+    masterKeySource: MasterKeySource;
+    /** Generated value, only when masterKeySource is 'environment'. */
+    masterKey?: string;
+    masterKeySecretId?: string;
+    /** How the server authenticates against AWS (S3 and/or Secrets Manager). */
+    awsAuth?: AwsAuth;
+    storage: Storage;
+    s3Provider?: S3Provider;
+    s3BucketName?: string;
+    awsRegion?: string;
+    awsBaseEndpoint?: string;
+    forcePathStyle?: boolean;
+    gcsBucketName?: string;
+    azureContainerName?: string;
+    azureAccountName?: string;
+    delivery: Delivery;
+    cdnBaseUrl?: string;
+    replicas: Replicas;
+    cacheMode: CacheMode;
+    redisHost?: string;
+    redisPort?: string;
+    /** Always true in the wizard; only inference from an existing file can turn it off. */
+    dashboard?: boolean;
+    adminEmail?: string;
+    adminPassword?: string;
+    deployment: Deployment;
+    observe: boolean;
+    clickhouseUrl?: string;
+    geoip: boolean;
+    geoipStrategy?: GeoipStrategy;
+    maxmindAccountId?: string;
+    maxmindLicenseKey?: string;
+};
+/**
+ * Delivery routes available per storage backend. GCS and Azure sign URLs with
+ * the storage credential itself and have no server-side switch to stream
+ * assets instead, so 'through-server' only exists for the s3 family
+ * (DISABLE_S3_DIRECT_CDN). Generic CDN is always listed last.
+ */
+export declare function deliveryOptionsFor(storage: Storage): Delivery[];
+export declare function cacheOptionsFor(replicas: Replicas): CacheMode[];
+export declare const S3_PROVIDER_DEFAULTS: Record<S3Provider, {
+    label: string;
+    endpoint: string;
+    region: string;
+    forcePathStyle: boolean;
+}>;
+/** True when the generated env must carry AWS access keys. */
+export declare function needsAwsAccessKeys(choices: ServerChoices): boolean;

package/dist/lib/serverConfig/choices.js

@@ -0,0 +1,65 @@
+"use strict";
+// The server:init decision model: every choice the wizard collects, and the
+// option sets that depend on previous answers. The env catalog
+// (envCatalog.ts) and the helm generator (helmValues.ts) consume it.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.needsAwsAccessKeys = exports.S3_PROVIDER_DEFAULTS = exports.cacheOptionsFor = exports.deliveryOptionsFor = void 0;
+/**
+ * Delivery routes available per storage backend. GCS and Azure sign URLs with
+ * the storage credential itself and have no server-side switch to stream
+ * assets instead, so 'through-server' only exists for the s3 family
+ * (DISABLE_S3_DIRECT_CDN). Generic CDN is always listed last.
+ */
+function deliveryOptionsFor(storage) {
+    switch (storage) {
+        case 'aws-s3':
+            return ['cloudfront', 'presigned', 'through-server', 'generic-cdn'];
+        case 's3-compatible':
+            return ['presigned', 'through-server', 'generic-cdn'];
+        case 'gcs':
+        case 'azure':
+            return ['presigned', 'generic-cdn'];
+    }
+}
+exports.deliveryOptionsFor = deliveryOptionsFor;
+function cacheOptionsFor(replicas) {
+    return replicas === 'multi' ? ['redis', 'redis-sentinel'] : ['redis', 'redis-sentinel', 'local'];
+}
+exports.cacheOptionsFor = cacheOptionsFor;
+exports.S3_PROVIDER_DEFAULTS = {
+    'cloudflare-r2': {
+        label: 'Cloudflare R2',
+        endpoint: 'https://<account-id>.r2.cloudflarestorage.com',
+        region: 'auto',
+        forcePathStyle: false,
+    },
+    minio: {
+        label: 'MinIO',
+        endpoint: 'https://<your-minio-host>',
+        region: 'us-east-1',
+        forcePathStyle: true,
+    },
+    'digitalocean-spaces': {
+        label: 'DigitalOcean Spaces',
+        endpoint: 'https://<region>.digitaloceanspaces.com',
+        region: 'us-east-1',
+        forcePathStyle: false,
+    },
+    supabase: {
+        label: 'Supabase Storage',
+        endpoint: 'https://<project-ref>.storage.supabase.co/storage/v1/s3',
+        region: '<project-region>',
+        forcePathStyle: true,
+    },
+};
+/** True when the generated env must carry AWS access keys. */
+function needsAwsAccessKeys(choices) {
+    if (choices.storage === 's3-compatible') {
+        return true;
+    }
+    const usesAws = choices.storage === 'aws-s3' ||
+        choices.masterKeySource === 'aws-secrets-manager' ||
+        choices.delivery === 'cloudfront';
+    return usesAws && choices.awsAuth === 'access-keys';
+}
+exports.needsAwsAccessKeys = needsAwsAccessKeys;

package/dist/lib/serverConfig/envCatalog.d.ts

@@ -0,0 +1,41 @@
+import { type ServerChoices } from './choices';
+export type EnvVarSpec = {
+    name: string;
+    applies: (c: ServerChoices) => boolean;
+    /** Required to boot the server; false renders the var commented out. */
+    required: boolean;
+    value: (c: ServerChoices) => string;
+    comment?: string;
+    /** Helm values key when the chart computes this var from a toggle. */
+    helmKey?: string;
+    /** Missing or placeholder value is a warning, not an error (the server boots without it). */
+    lenient?: boolean;
+};
+export type EnvSection = {
+    title: string;
+    note?: (c: ServerChoices) => string | undefined;
+    vars: EnvVarSpec[];
+};
+export declare const ENV_SECTIONS: EnvSection[];
+export declare function applicableVars(choices: ServerChoices): EnvVarSpec[];
+export declare function isPlaceholder(value: string): boolean;
+/** Renders the .env.xprem content for the wizard's choices. */
+export declare function renderEnvFile(choices: ServerChoices): string;
+/** Parses a dotenv-style file into a name/value map. Commented vars are skipped. */
+export declare function parseEnvFile(content: string): Record<string, string>;
+export type ValidationIssue = {
+    level: 'error' | 'warning';
+    message: string;
+};
+/**
+ * Rebuilds the wizard choices implied by an env map, so the catalog's
+ * applicability rules can run against an existing file.
+ */
+export declare function inferChoicesFromEnv(env: Record<string, string>): ServerChoices;
+/**
+ * Validates an env map against the catalog: every applicable required var is
+ * present, no placeholder is left, and the server's own consistency rules
+ * hold. Local storage mode is accepted (it has working defaults) even though
+ * the wizard never generates it.
+ */
+export declare function validateEnvMap(env: Record<string, string>, overrides?: Partial<ServerChoices>): ValidationIssue[];