@devicecloud.dev/dcd 5.0.0-beta.3 → 5.0.0-beta.4

package/dist/commands/cloud.js

@@ -16,9 +16,10 @@ import { TestSubmissionService } from '../services/test-submission.service.js';
 import { VersionService } from '../services/version.service.js';
 import { EAndroidApiLevels, EAndroidDevices, EiOSDevices, EiOSVersions, } from '../types/domain/device.types.js';
 import { resolveAuth } from '../utils/auth.js';
-import { isCI } from '../utils/ci.js';
+import { detectCiContext, isCI } from '../utils/ci.js';
 import { CliError, coerceArray, collectRepeatedFlag, getCliVersion, getUpgradeCommand, logger, parseIntFlag, validateEnum, } from '../utils/cli.js';
 import { fetchCompatibilityData, } from '../utils/compatibility.js';
+import { renderNotices } from '../services/notices.service.js';
 import { resolveApiUrl } from '../utils/config-store.js';
 import { downloadExpoUrl, extractTarGz, findAppBundle, isUrl } from '../utils/expo.js';
 import { colors, formatId, formatUrl, getConsoleUrl, } from '../utils/styling.js';
@@ -220,9 +221,14 @@ export const cloudCommand = defineCommand({
             if (auth.mode === 'apiKey' && !json && !quiet && !isCI()) {
                 out(colors.dim('Tip: run `dcd login` for live test updates and a smoother experience than passing --api-key.'));
             }
+            const ciContext = detectCiContext();
             let compatibilityData;
             try {
-                compatibilityData = await fetchCompatibilityData(apiUrl, auth);
+                compatibilityData = await fetchCompatibilityData(apiUrl, auth, {
+                    cliVersion,
+                    ciProvider: ciContext.provider,
+                    ciWrapperVersion: ciContext.wrapperVersion,
+                });
                 if (debug) {
                     out('[DEBUG] Successfully fetched compatibility data from API');
                 }
@@ -241,17 +247,6 @@ export const cloudCommand = defineCommand({
                 debug,
                 logger: (m) => out(m),
             });
-            // Soft deprecation notice for Maestro versions slated for removal on
-            // 26 June 2026. Non-fatal — these still run during the grace period.
-            const DEPRECATED_MAESTRO_VERSIONS = ['1.39.5', '1.41.0'];
-            if (DEPRECATED_MAESTRO_VERSIONS.includes(resolvedMaestroVersion)) {
-                warnOut(ui.warn(colors.bold(`Maestro ${resolvedMaestroVersion} is deprecated`)));
-                warnOut(ui.branch([
-                    `Maestro ${resolvedMaestroVersion} will be removed on 26 June 2026; after that, tests pinned to it will fail.`,
-                    'Upgrade to Maestro 2.6.0 or above.',
-                    `${colors.dim('See:')} ${colors.url('https://docs.devicecloud.dev/configuration/maestro-versions')}`,
-                ]));
-            }
             if (retry !== undefined && retry > 2) {
                 out(ui.warn('Retries are now free of charge but limited to 2. If your test is still failing after 2 retries, please ask for help on Discord.'));
                 retry = 2;
@@ -319,18 +314,17 @@ export const cloudCommand = defineCommand({
                 debug,
                 logger: (m) => out(m),
             });
-            // iOS 16 deprecation notice (soft warning during the grace period;
-            // removed on 23 August 2026). Only fires on an explicit --ios-version 16 —
-            // when omitted the API defaults to iOS 17, so no false warning.
-            const DEPRECATED_IOS_VERSIONS = ['16'];
-            if (iOSVersion && DEPRECATED_IOS_VERSIONS.includes(iOSVersion)) {
-                warnOut(ui.warn(colors.bold('iOS 16 is deprecated')));
-                warnOut(ui.branch([
-                    'iOS 16 will be removed on 23 August 2026; after that, tests targeting it will fail.',
-                    'Switch to iOS 17 or newer — iPhone 14 also supports 17 and 18.',
-                    `${colors.dim('See:')} ${colors.url('https://docs.devicecloud.dev/getting-started/devices-configuration')}`,
-                ]));
-            }
+            // Render DB-driven notices (deprecation/warn/info/marketing) the API
+            // returned with the compatibility data. Replaces the previously hardcoded
+            // iOS-16 deprecation warning — that is now a seeded notice gated on the
+            // selected iOS version below. Honours --json via out/warnOut.
+            renderNotices(compatibilityData.notices, {
+                ios_version: iOSVersion,
+                android_api_level: androidApiLevel,
+                cli_version: cliVersion,
+                ci_provider: ciContext.provider,
+                ci_wrapper_version: ciContext.wrapperVersion,
+            }, { out, warnOut });
             deviceValidationService.validateAndroidDevice(androidApiLevel, androidDevice, googlePlay, compatibilityData, { debug, logger: (m) => out(m) });
             if (maestroChromeOnboarding && !androidApiLevel && !androidDevice) {
                 warnOut('The --maestro-chrome-onboarding flag only applies to Android tests and will be ignored for iOS tests.');

package/dist/services/notices.service.d.ts

@@ -0,0 +1,40 @@
+export type NoticeLevel = 'deprecation' | 'warn' | 'info' | 'marketing';
+export interface NoticeMatchRule {
+    field: string;
+    op: 'present' | 'absent' | 'equals' | 'in' | 'not_in' | 'lt' | 'gt';
+    value?: unknown;
+}
+export interface NoticeMatch {
+    rules: NoticeMatchRule[];
+}
+/**
+ * The client-facing notice shape returned by the API (embedded in the
+ * compatibility response and from GET /notices). `match` is an optional display
+ * gate the CLI evaluates locally against its own context (e.g. the selected iOS
+ * version) — the API can't know those at fetch time.
+ */
+export interface Notice {
+    id: string;
+    slug: string | null;
+    level: NoticeLevel;
+    title: string;
+    body: string;
+    learnMoreUrl: string | null;
+    dismissible: boolean;
+    match: NoticeMatch | null;
+}
+/** Flat key/value context the `match` DSL is evaluated against. */
+export type NoticeContext = Record<string, unknown>;
+/** A null / empty match imposes no constraint; otherwise every rule must match (AND). */
+export declare function matchesRules(match: NoticeMatch | null | undefined, ctx: NoticeContext): boolean;
+export interface RenderNoticesOptions {
+    out: (message: string) => void;
+    warnOut: (message: string) => void;
+}
+/**
+ * Filter notices by their local-context `match` gate and render those that pass.
+ * Returns the visible notices so a `--json` caller can include them in its
+ * payload instead of printing. When `--json` is active, callers pass no-op
+ * out/warnOut so nothing is printed but the list is still returned.
+ */
+export declare function renderNotices(notices: Notice[] | undefined, ctx: NoticeContext, opts: RenderNoticesOptions): Notice[];

package/dist/services/notices.service.js

@@ -0,0 +1,80 @@
+import { ui } from '../utils/ui.js';
+import { colors } from '../utils/styling.js';
+import { compareSemver } from './version.service.js';
+function isPresent(raw) {
+    return raw !== null && raw !== undefined && raw !== false && raw !== '';
+}
+function ruleMatches(rule, ctx) {
+    const raw = ctx[rule.field];
+    switch (rule.op) {
+        case 'present':
+            return isPresent(raw);
+        case 'absent':
+            return !isPresent(raw);
+        case 'equals':
+            return isPresent(raw) && String(raw) === String(rule.value);
+        case 'in':
+            return (isPresent(raw) &&
+                Array.isArray(rule.value) &&
+                rule.value.map(String).includes(String(raw)));
+        case 'not_in':
+            return (isPresent(raw) &&
+                Array.isArray(rule.value) &&
+                !rule.value.map(String).includes(String(raw)));
+        case 'lt':
+            return (isPresent(raw) &&
+                rule.value != null &&
+                compareSemver(String(raw), String(rule.value)) < 0);
+        case 'gt':
+            return (isPresent(raw) &&
+                rule.value != null &&
+                compareSemver(String(raw), String(rule.value)) > 0);
+        default:
+            return false;
+    }
+}
+/** A null / empty match imposes no constraint; otherwise every rule must match (AND). */
+export function matchesRules(match, ctx) {
+    if (!match || !Array.isArray(match.rules) || match.rules.length === 0) {
+        return true;
+    }
+    return match.rules.every((rule) => ruleMatches(rule, ctx));
+}
+/** Render a single notice with styling appropriate to its level. */
+function renderNotice(notice, opts) {
+    const rows = [notice.body];
+    if (notice.learnMoreUrl) {
+        rows.push(`${colors.dim('See:')} ${colors.url(notice.learnMoreUrl)}`);
+    }
+    switch (notice.level) {
+        case 'deprecation':
+        case 'warn':
+            opts.warnOut(ui.warn(colors.bold(notice.title)));
+            opts.warnOut(ui.branch(rows));
+            break;
+        case 'marketing':
+            opts.out(ui.section(notice.title));
+            opts.out(ui.branch(rows));
+            break;
+        case 'info':
+        default:
+            opts.out(ui.info(colors.bold(notice.title)));
+            opts.out(ui.branch(rows));
+            break;
+    }
+}
+/**
+ * Filter notices by their local-context `match` gate and render those that pass.
+ * Returns the visible notices so a `--json` caller can include them in its
+ * payload instead of printing. When `--json` is active, callers pass no-op
+ * out/warnOut so nothing is printed but the list is still returned.
+ */
+export function renderNotices(notices, ctx, opts) {
+    if (!notices || notices.length === 0)
+        return [];
+    const visible = notices.filter((n) => matchesRules(n.match, ctx));
+    for (const notice of visible) {
+        renderNotice(notice, opts);
+    }
+    return visible;
+}

package/dist/services/version.service.d.ts

@@ -14,6 +14,19 @@ export type LatestVersionResult = {
     ok: false;
     error: string;
 };
+/**
+ * Compare two semantic versions per SemVer 2.0.0 precedence rules.
+ * Returns a negative number if `a < b`, positive if `a > b`, and 0 if equal.
+ *
+ * Implements the prerelease rules that the previous naive comparator dropped:
+ *   - A version WITH a prerelease has lower precedence than the same version
+ *     without one ("1.0.0-beta" < "1.0.0").
+ *   - Prerelease identifiers are compared dot-separated, left to right:
+ *     numeric identifiers compare numerically, alphanumeric ones compare
+ *     lexically (ASCII), and numeric always sorts below alphanumeric. A longer
+ *     set of identifiers wins when all preceding ones are equal.
+ */
+export declare function compareSemver(a: string, b: string): number;
 /**
  * Service for handling version validation and checking
  */

package/dist/services/version.service.js

@@ -12,7 +12,7 @@ const MANIFEST_TIMEOUT_MS = 3000;
  *     lexically (ASCII), and numeric always sorts below alphanumeric. A longer
  *     set of identifiers wins when all preceding ones are equal.
  */
-function compareSemver(a, b) {
+export function compareSemver(a, b) {
     const split = (v) => {
         const [core, ...preParts] = v.trim().replace(/^v/, '').split('-');
         const nums = core.split('.').map((n) => Number(n) || 0);

package/dist/utils/ci.d.ts

@@ -10,3 +10,18 @@
  * counts — providers set `CI=true`, but a bare presence check is the safe net.
  */
 export declare function isCI(): boolean;
+/** Which DCD CI integration (if any) is wrapping this CLI invocation, and its version. */
+export interface CiContext {
+    /** e.g. 'github' | 'bitrise' | 'bitbucket' | 'eas' | 'gitlab' | 'circleci'. */
+    provider: string | null;
+    /** The wrapper's own version, if it forwarded one (DCD_CI_WRAPPER_VERSION). */
+    wrapperVersion: string | null;
+}
+/**
+ * Resolve the CI integration context the CLI forwards to the notices API so
+ * notices can target a specific integration/version (e.g. "Bitbucket Pipe <
+ * 1.1.0"). The DCD CI wrappers set `DCD_CI_PROVIDER` / `DCD_CI_WRAPPER_VERSION`
+ * explicitly (preferred — carries the wrapper version); otherwise the provider
+ * is inferred from native env vars and the version is unknown.
+ */
+export declare function detectCiContext(): CiContext;

package/dist/utils/ci.js

@@ -37,3 +37,35 @@ export function isCI() {
     }
     return !process.stdout.isTTY;
 }
+/** Infer the CI provider from the env vars each platform sets natively. */
+function inferProvider() {
+    const env = process.env;
+    if (env.GITHUB_ACTIONS)
+        return 'github';
+    if (env.BITRISE_IO || env.BITRISE_BUILD_NUMBER)
+        return 'bitrise';
+    if (env.BITBUCKET_BUILD_NUMBER)
+        return 'bitbucket';
+    if (env.EAS_BUILD || env.EAS_BUILD_RUNNER || env.EAS_BUILD_ID)
+        return 'eas';
+    if (env.GITLAB_CI)
+        return 'gitlab';
+    if (env.CIRCLECI)
+        return 'circleci';
+    return null;
+}
+/**
+ * Resolve the CI integration context the CLI forwards to the notices API so
+ * notices can target a specific integration/version (e.g. "Bitbucket Pipe <
+ * 1.1.0"). The DCD CI wrappers set `DCD_CI_PROVIDER` / `DCD_CI_WRAPPER_VERSION`
+ * explicitly (preferred — carries the wrapper version); otherwise the provider
+ * is inferred from native env vars and the version is unknown.
+ */
+export function detectCiContext() {
+    const forwardedProvider = process.env.DCD_CI_PROVIDER?.trim();
+    const forwardedVersion = process.env.DCD_CI_WRAPPER_VERSION?.trim();
+    return {
+        provider: forwardedProvider || inferProvider(),
+        wrapperVersion: forwardedVersion || null,
+    };
+}

package/dist/utils/compatibility.d.ts

@@ -1,4 +1,5 @@
 import type { AuthContext } from '../types/domain/auth.types.js';
+import type { Notice } from '../services/notices.service.js';
 export interface CompatibilityData {
     android: Record<string, string[]>;
     androidPlay: Record<string, string[]>;
@@ -8,6 +9,14 @@ export interface CompatibilityData {
         latestVersion: string;
         supportedVersions: string[];
     };
+    /** Active CLI notices, piggybacked onto the compatibility response by the API. */
+    notices?: Notice[];
 }
-export declare function fetchCompatibilityData(apiUrl: string, auth: AuthContext): Promise<CompatibilityData>;
+/** Identity the CLI forwards so the API can target notices by version / CI. */
+export interface ClientContext {
+    cliVersion?: string;
+    ciProvider?: string | null;
+    ciWrapperVersion?: string | null;
+}
+export declare function fetchCompatibilityData(apiUrl: string, auth: AuthContext, clientContext?: ClientContext): Promise<CompatibilityData>;
 export declare function clearCompatibilityCache(): void;

package/dist/utils/compatibility.js

@@ -1,13 +1,25 @@
 let cachedCompatibilityData = null;
-export async function fetchCompatibilityData(apiUrl, auth) {
+export async function fetchCompatibilityData(apiUrl, auth, clientContext) {
     if (cachedCompatibilityData) {
         return cachedCompatibilityData;
     }
+    // Forward CLI / CI identity so the API can version-filter and target notices.
+    const noticeHeaders = {};
+    if (clientContext?.cliVersion) {
+        noticeHeaders['x-dcd-cli-version'] = clientContext.cliVersion;
+    }
+    if (clientContext?.ciProvider) {
+        noticeHeaders['x-dcd-ci-provider'] = clientContext.ciProvider;
+    }
+    if (clientContext?.ciWrapperVersion) {
+        noticeHeaders['x-dcd-ci-wrapper-version'] = clientContext.ciWrapperVersion;
+    }
     try {
         const response = await fetch(`${apiUrl}/results/compatibility/data`, {
             headers: {
                 'Content-Type': 'application/json',
                 ...auth.headers,
+                ...noticeHeaders,
             },
             method: 'GET',
         });

package/package.json

@@ -60,7 +60,7 @@
     "type": "git",
     "url": "https://devicecloud.dev"
   },
-  "version": "5.0.0-beta.3",
+  "version": "5.0.0-beta.4",
   "bugs": {
     "url": "https://discord.gg/gm3mJwcNw8"
   },