eoas 3.1.2-beta2 → 3.1.2-beta4

package/dist/commands/publish.d.ts

@@ -15,6 +15,7 @@ export default class Publish extends Command {
         message: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         dumpSourcemap: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         'rollout-percentage': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'upload-rate': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     private sanitizeFlags;
     run(): Promise<void>;

package/dist/commands/publish.js

@@ -18,6 +18,7 @@ const ora_1 = require("../lib/ora");
 const package_1 = require("../lib/package");
 const packageRunner_1 = require("../lib/packageRunner");
 const prompts_1 = require("../lib/prompts");
+const rateLimiter_1 = require("../lib/rateLimiter");
 const repo_1 = require("../lib/repo");
 const runtimeVersion_1 = require("../lib/runtimeVersion");
 const vcs_1 = require("../lib/vcs");
@@ -79,8 +80,17 @@ class Publish extends core_1.Command {
             max: 99,
             description: 'Publish this update as a progressive rollout served to N% of devices (1-99). The remaining devices keep receiving the previous update of each branch/runtime version. With --platform all, the rollout applies independently to each platform. Progression (increase, end, revert) is managed from the dashboard.',
         }),
+        'upload-rate': core_1.Flags.string({
+            description: 'Maximum number of asset uploads started per second. Accepts decimals (e.g. 1.5). Lower this if your storage provider rate-limits uploads.',
+            default: '10',
+        }),
     };
     sanitizeFlags(flags) {
+        const uploadRate = Number(flags['upload-rate']);
+        if (!Number.isFinite(uploadRate) || uploadRate <= 0) {
+            log_1.default.error('--upload-rate must be a positive number');
+            process.exit(1);
+        }
         return {
             disableRepositoryCheck: flags.disableRepositoryCheck,
             platform: flags.platform,
@@ -93,6 +103,7 @@ class Publish extends core_1.Command {
             message: flags.message,
             dumpSourcemap: flags.dumpSourcemap,
             rolloutPercentage: flags['rollout-percentage'],
+            uploadRate,
         };
     }
     async run() {
@@ -102,11 +113,14 @@ class Publish extends core_1.Command {
             process.exit(1);
         }
         const { flags } = await this.parse(Publish);
-        const { platform, nonInteractive, branch, customServerUrl, outputDir, packageRunner, providedDeprecatedChannel, disableRepositoryCheck, message, dumpSourcemap, rolloutPercentage, } = this.sanitizeFlags(flags);
+        const { platform, nonInteractive, branch, customServerUrl, outputDir, packageRunner, providedDeprecatedChannel, disableRepositoryCheck, message, dumpSourcemap, rolloutPercentage, uploadRate, } = this.sanitizeFlags(flags);
         if (!branch) {
             log_1.default.error('Branch name is required');
             process.exit(1);
         }
+        // Bucket capacity is ~1s of budget so a low --upload-rate also caps the
+        // initial burst, not just the steady rate.
+        const publishAssetsRateLimiter = new rateLimiter_1.RateLimiter('publish-eoas-assets', Math.max(1, Math.ceil(uploadRate)), uploadRate);
         const projectDir = process.cwd();
         const hasExpo = (0, package_1.isExpoInstalled)(projectDir);
         if (!hasExpo) {
@@ -289,13 +303,18 @@ class Publish extends core_1.Command {
                 manifest: files,
             })))).flat();
             await Promise.all(resolvedUploads.map(async ({ item: itm, absolutePath, manifestEntry }) => {
+                await publishAssetsRateLimiter.take();
                 const isLocalBucketFileUpload = itm.requestUploadUrl.startsWith(`${serverUrl}/${appId}/uploadLocalFile`);
                 if (isLocalBucketFileUpload) {
-                    const formData = new form_data_1.default();
-                    const file = fs_extra_1.default.createReadStream(absolutePath);
-                    formData.append(itm.fileName, file);
-                    try {
-                        const response = await (0, fetch_1.fetchWithRetries)(itm.requestUploadUrl, {
+                    // A stream-backed body is consumed by the first attempt, so each
+                    // retry rebuilds the multipart body from a buffer.
+                    const fileBuffer = await fs_extra_1.default.readFile(absolutePath);
+                    const response = await (0, fetch_1.fetchWithRetriesRebuildingBody)(itm.requestUploadUrl, () => {
+                        const formData = new form_data_1.default();
+                        formData.append(itm.fileName, fileBuffer, {
+                            filename: path_1.default.basename(absolutePath),
+                        });
+                        return {
                             method: 'PUT',
                             headers: {
                                 ...formData.getHeaders(),
@@ -305,14 +324,11 @@ class Publish extends core_1.Command {
                             // The URL was validated as a string; following a redirect would
                             // send these bytes to an origin nothing ever checked.
                             redirect: 'error',
-                        });
-                        if (!response.ok) {
-                            log_1.default.error('Failed to upload file', await response.text());
-                            throw new Error('Failed to upload file');
-                        }
-                    }
-                    finally {
-                        file.close();
+                        };
+                    });
+                    if (!response.ok) {
+                        log_1.default.error('Failed to upload file', await response.text());
+                        throw new Error('Failed to upload file');
                     }
                     return;
                 }

package/dist/commands/republish.js

@@ -11,6 +11,7 @@ const package_1 = require("../lib/package");
 const prompts_1 = require("../lib/prompts");
 const serverUpdates_1 = require("../lib/serverUpdates");
 const vcs_1 = require("../lib/vcs");
+const REPUBLISH_PAGE_SIZE = 20;
 class Publish extends core_1.Command {
     static args = {};
     static description = 'Republish a previous update to a branch';
@@ -93,31 +94,27 @@ class Publish extends core_1.Command {
             })),
         });
         log_1.default.log(`Selected runtime version: ${selectedRuntimeVersion.runtimeVersion}`);
-        let allUpdates;
-        try {
-            allUpdates = await (0, serverUpdates_1.fetchUpdates)({
-                baseUrl,
-                appId,
-                branch,
-                runtimeVersion: selectedRuntimeVersion.runtimeVersion,
-                credentials,
-            });
-        }
-        catch (e) {
-            log_1.default.error(e instanceof Error ? e.message : e);
-            process.exit(1);
-        }
-        // Rollback markers have no files to republish.
-        const updates = allUpdates.filter(u => u.updateUUID !== 'Rollback to embedded');
-        if (updates.length === 0) {
-            log_1.default.error(`No republishable updates found for runtime version ${selectedRuntimeVersion.runtimeVersion}.`);
-            process.exit(1);
+        let firstGroupsPage = null;
+        if (platform === 'all') {
+            try {
+                firstGroupsPage = await (0, serverUpdates_1.fetchPublishGroups)({
+                    baseUrl,
+                    appId,
+                    branch,
+                    runtimeVersion: selectedRuntimeVersion.runtimeVersion,
+                    credentials,
+                    limit: REPUBLISH_PAGE_SIZE,
+                });
+            }
+            catch (e) {
+                log_1.default.error(e instanceof Error ? e.message : e);
+                process.exit(1);
+            }
         }
-        const { groups } = (0, serverUpdates_1.groupPublishedUpdates)(updates);
-        // Offer the group mode only when there is something to group and the user
-        // did not already narrow the run to one platform.
+        // Publish groups are a control-plane read model. Servers without that
+        // capability return no group page and keep the single-update flow.
         let mode = 'single';
-        if (platform === 'all' && groups.length > 0) {
+        if (firstGroupsPage && firstGroupsPage.items.length > 0) {
             const selectedMode = await (0, prompts_1.promptAsync)({
                 type: 'select',
                 name: 'mode',
@@ -138,16 +135,58 @@ class Publish extends core_1.Command {
             mode = selectedMode.mode;
         }
         if (mode === 'group') {
-            const selectedGroup = await (0, prompts_1.promptAsync)({
-                type: 'select',
-                name: 'group',
-                message: 'Select a publish to republish',
-                choices: groups.map(group => ({
-                    ...(0, serverUpdates_1.describePublishGroup)(group),
-                    value: group,
-                })),
-            });
-            const group = selectedGroup.group;
+            if (!firstGroupsPage) {
+                log_1.default.error('Publish group listing is not available');
+                process.exit(1);
+            }
+            const groups = [...firstGroupsPage.items];
+            let nextGroupCursor = firstGroupsPage.nextCursor;
+            let group;
+            let initialChoiceIndex = 0;
+            while (!group) {
+                const choices = groups.map(candidate => ({
+                    ...(0, serverUpdates_1.describePublishGroup)(candidate),
+                    value: { kind: 'group', group: candidate },
+                }));
+                if (nextGroupCursor) {
+                    choices.push({ title: 'Load more publishes', value: { kind: 'loadMore' } });
+                }
+                const selectedGroup = await (0, prompts_1.promptAsync)({
+                    type: 'select',
+                    name: 'group',
+                    message: 'Select a publish to republish',
+                    choices,
+                    initial: initialChoiceIndex,
+                });
+                const selection = selectedGroup.group;
+                if (selection.kind === 'loadMore') {
+                    const previousGroupCount = groups.length;
+                    try {
+                        const page = await (0, serverUpdates_1.fetchPublishGroups)({
+                            baseUrl,
+                            appId,
+                            branch,
+                            runtimeVersion: selectedRuntimeVersion.runtimeVersion,
+                            credentials,
+                            cursor: nextGroupCursor ?? undefined,
+                            limit: REPUBLISH_PAGE_SIZE,
+                        });
+                        if (!page) {
+                            throw new Error('Publish group listing is no longer available');
+                        }
+                        groups.push(...page.items);
+                        nextGroupCursor = page.nextCursor;
+                    }
+                    catch (e) {
+                        log_1.default.error(e instanceof Error ? e.message : e);
+                        process.exit(1);
+                    }
+                    initialChoiceIndex = Math.min(previousGroupCount, Math.max(0, groups.length - 1));
+                }
+                else {
+                    group = selection.group;
+                }
+            }
             const republishUrl = new URL(`${baseUrl}/${appId}/republish/${branch}`);
             republishUrl.searchParams.set('runtimeVersion', selectedRuntimeVersion.runtimeVersion);
             republishUrl.searchParams.set('publishGroup', group.publishGroup);
@@ -171,27 +210,78 @@ class Publish extends core_1.Command {
                 : `✅ Republished ${group.platforms.join(' + ')}`);
             return;
         }
-        const platformUpdates = updates.filter(u => platform === 'all' || u.platform === platform);
-        if (platformUpdates.length === 0) {
+        const updates = [];
+        let nextCursor;
+        const loadNextPage = async () => {
+            const previousCount = updates.length;
+            do {
+                const page = await (0, serverUpdates_1.fetchUpdates)({
+                    baseUrl,
+                    appId,
+                    branch,
+                    runtimeVersion: selectedRuntimeVersion.runtimeVersion,
+                    credentials,
+                    cursor: nextCursor ?? undefined,
+                    limit: REPUBLISH_PAGE_SIZE,
+                });
+                // Rollbacks have no files to republish. Apply a requested platform
+                // before presenting pages, but do not fetch ahead merely to fill 20.
+                updates.push(...page.items.filter(update => update.updateUUID !== 'Rollback to embedded' &&
+                    (platform === 'all' || update.platform === platform)));
+                nextCursor = page.nextCursor;
+            } while (updates.length === previousCount && nextCursor);
+        };
+        try {
+            await loadNextPage();
+        }
+        catch (e) {
+            log_1.default.error(e instanceof Error ? e.message : e);
+            process.exit(1);
+        }
+        if (updates.length === 0 && !nextCursor) {
             log_1.default.error(`No republishable updates found for runtime version ${selectedRuntimeVersion.runtimeVersion} on platform ${platform}.`);
             process.exit(1);
         }
-        const selectedUpdated = await (0, prompts_1.promptAsync)({
-            type: 'select',
-            name: 'update',
-            message: 'Select an update to republish',
-            choices: platformUpdates.map(update => ({
+        let selectedUpdate;
+        let initialChoiceIndex = 0;
+        while (!selectedUpdate) {
+            const choices = updates.map(update => ({
                 title: update.updateUUID,
-                value: update,
+                value: { kind: 'update', update },
                 description: `Created at: ${update.createdAt}, Platform: ${update.platform}, Commit hash: ${update.commitHash}`,
-            })),
-        });
-        log_1.default.log(`Re-publishing update: ${selectedUpdated.update.updateUUID}`);
+            }));
+            if (nextCursor) {
+                choices.push({ title: 'Load more updates', value: { kind: 'loadMore' } });
+            }
+            const answer = await (0, prompts_1.promptAsync)({
+                type: 'select',
+                name: 'update',
+                message: 'Select an update to republish',
+                choices,
+                initial: initialChoiceIndex,
+            });
+            const selection = answer.update;
+            if (selection.kind === 'loadMore') {
+                const firstNewUpdateIndex = updates.length;
+                try {
+                    await loadNextPage();
+                }
+                catch (e) {
+                    log_1.default.error(e instanceof Error ? e.message : e);
+                    process.exit(1);
+                }
+                initialChoiceIndex = Math.min(firstNewUpdateIndex, Math.max(0, updates.length - 1));
+            }
+            else {
+                selectedUpdate = selection.update;
+            }
+        }
+        log_1.default.log(`Re-publishing update: ${selectedUpdate.updateUUID}`);
         const republishUrl = new URL(`${baseUrl}/${appId}/republish/${branch}`);
-        republishUrl.searchParams.set('platform', selectedUpdated.update.platform);
+        republishUrl.searchParams.set('platform', selectedUpdate.platform);
         republishUrl.searchParams.set('runtimeVersion', selectedRuntimeVersion.runtimeVersion);
-        republishUrl.searchParams.set('updateId', selectedUpdated.update.updateId);
-        republishUrl.searchParams.set('commitHash', selectedUpdated.update.commitHash);
+        republishUrl.searchParams.set('updateId', selectedUpdate.updateId);
+        republishUrl.searchParams.set('commitHash', selectedUpdate.commitHash);
         const republishSpinner = (0, ora_1.ora)('🔄 Republishing update...').start();
         const republishResponse = await (0, fetch_1.fetchWithRetries)(republishUrl.toString(), {
             method: 'POST',

package/dist/lib/fetch.d.ts

@@ -1,2 +1,6 @@
 import { RequestInit, Response } from 'node-fetch';
+export declare function isRetryableStatus(status: number): boolean;
+export declare function retryAfterMs(header: string | null): number | null;
+export declare function redactUrl(url: string): string;
 export declare function fetchWithRetries(url: string, options: RequestInit): Promise<Response>;
+export declare function fetchWithRetriesRebuildingBody(url: string, makeOptions: () => RequestInit): Promise<Response>;

package/dist/lib/fetch.js

@@ -1,27 +1,103 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchWithRetries = void 0;
+exports.fetchWithRetriesRebuildingBody = exports.fetchWithRetries = exports.redactUrl = exports.retryAfterMs = exports.isRetryableStatus = void 0;
 const tslib_1 = require("tslib");
 const fetch_retry_1 = tslib_1.__importDefault(require("fetch-retry"));
 const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
 const log_1 = tslib_1.__importDefault(require("./log"));
 const fetch = (0, fetch_retry_1.default)(node_fetch_1.default);
+function isRetryableStatus(status) {
+    return status === 429 || status >= 500;
+}
+exports.isRetryableStatus = isRetryableStatus;
+// Retry-After is either delay-seconds or an HTTP-date.
+function retryAfterMs(header) {
+    if (!header) {
+        return null;
+    }
+    const seconds = Number(header);
+    if (Number.isFinite(seconds)) {
+        return seconds * 1000;
+    }
+    const dateMs = Date.parse(header);
+    if (!Number.isNaN(dateMs)) {
+        return dateMs - Date.now();
+    }
+    return null;
+}
+exports.retryAfterMs = retryAfterMs;
+const MAX_RETRY_DELAY_MS = 60000;
+const MAX_RETRIED_ATTEMPT = 3;
+// Upload URLs carry their credentials in the query string (S3 presign, Azure
+// SAS, the local bucket's upload token), so logs may only show origin and path.
+function redactUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return parsed.origin + parsed.pathname;
+    }
+    catch {
+        return '<unparseable url>';
+    }
+}
+exports.redactUrl = redactUrl;
+function retryDelayForResponse(attempt, response) {
+    const serverDelay = retryAfterMs(response.headers.get('retry-after'));
+    const backoff = Math.pow(2, attempt) * 2000;
+    return Math.min(Math.max(serverDelay ?? 0, backoff), MAX_RETRY_DELAY_MS);
+}
 async function fetchWithRetries(url, options) {
     return await fetch(url, {
         ...options,
-        retryDelay(attempt) {
+        retryDelay(attempt, _error, response) {
+            if (response) {
+                return retryDelayForResponse(attempt, response);
+            }
             return Math.pow(2, attempt) * 500;
         },
-        retryOn: (attempt, error) => {
-            if (attempt > 3) {
+        retryOn: (attempt, error, response) => {
+            if (attempt > MAX_RETRIED_ATTEMPT) {
                 return false;
             }
             if (error) {
                 log_1.default.warn(`Retry ${attempt} after network error:`, error.message);
                 return true;
             }
+            if (response && isRetryableStatus(response.status)) {
+                log_1.default.warn(`Retry ${attempt} after HTTP ${response.status} from ${redactUrl(url)}`);
+                return true;
+            }
             return false;
         },
     });
 }
 exports.fetchWithRetries = fetchWithRetries;
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+// fetch-retry re-sends the same RequestInit on every attempt, which silently
+// replays an already-consumed stream body as empty. Callers with a one-shot
+// body (multipart uploads) use this variant: makeOptions rebuilds the body
+// for each attempt. Same retry policy as fetchWithRetries.
+async function fetchWithRetriesRebuildingBody(url, makeOptions) {
+    for (let attempt = 0;; attempt++) {
+        let response;
+        try {
+            response = await (0, node_fetch_1.default)(url, makeOptions());
+        }
+        catch (error) {
+            if (attempt > MAX_RETRIED_ATTEMPT) {
+                throw error;
+            }
+            log_1.default.warn(`Retry ${attempt} after network error:`, error.message);
+            await sleep(Math.pow(2, attempt) * 500);
+            continue;
+        }
+        if (attempt <= MAX_RETRIED_ATTEMPT && isRetryableStatus(response.status)) {
+            log_1.default.warn(`Retry ${attempt} after HTTP ${response.status} from ${redactUrl(url)}`);
+            await sleep(retryDelayForResponse(attempt, response));
+            continue;
+        }
+        return response;
+    }
+}
+exports.fetchWithRetriesRebuildingBody = fetchWithRetriesRebuildingBody;

package/dist/lib/rateLimiter.d.ts

@@ -0,0 +1,7 @@
+export declare class RateLimiter {
+    private readonly key;
+    private readonly capacity;
+    private readonly refillRate;
+    constructor(key: string, capacity: number, refillRate: number);
+    take(): Promise<void>;
+}

package/dist/lib/rateLimiter.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimiter = void 0;
+const kv = {};
+class RateLimiter {
+    key;
+    capacity;
+    refillRate;
+    constructor(key, capacity, refillRate) {
+        this.key = key;
+        this.capacity = capacity;
+        this.refillRate = refillRate;
+    }
+    async take() {
+        const now = Date.now();
+        const bucket = kv[this.key];
+        let tokens = bucket ? bucket.tokens : this.capacity;
+        const lastRefill = bucket ? bucket.lastRefill : now;
+        const elapsed = (now - lastRefill) / 1000;
+        tokens = Math.min(this.capacity, tokens + elapsed * this.refillRate);
+        if (tokens < 1) {
+            const waitMs = ((1 - tokens) / this.refillRate) * 1000;
+            await new Promise(res => setTimeout(res, waitMs));
+            await this.take();
+            return;
+        }
+        tokens -= 1;
+        kv[this.key] = {
+            tokens,
+            lastRefill: now,
+        };
+    }
+}
+exports.RateLimiter = RateLimiter;

package/dist/lib/serverUpdates.d.ts

@@ -14,27 +14,52 @@ export interface ServerUpdateItem {
     message?: string;
     publishGroup?: string;
 }
+export interface ServerUpdatesPage {
+    items: ServerUpdateItem[];
+    nextCursor: string | null;
+}
+export interface PublishGroupUpdateItem {
+    updateId: string;
+    createdAt: string;
+    platform: string;
+    commitHash: string;
+}
+export interface PublishGroupSummary {
+    publishGroup: string;
+    platforms: string[];
+    commitHash: string;
+    message?: string;
+    createdAt: string;
+    updates: PublishGroupUpdateItem[];
+}
+export interface ServerPublishGroupsPage {
+    items: PublishGroupSummary[];
+    nextCursor: string | null;
+}
 export declare function fetchRuntimeVersions({ baseUrl, appId, branch, credentials, }: {
     baseUrl: string;
     appId: string;
     branch: string;
     credentials: Credentials;
 }): Promise<RuntimeVersionInfo[]>;
-export declare function fetchUpdates({ baseUrl, appId, branch, runtimeVersion, credentials, }: {
+export declare function fetchUpdates({ baseUrl, appId, branch, runtimeVersion, credentials, cursor, limit, }: {
     baseUrl: string;
     appId: string;
     branch: string;
     runtimeVersion: string;
     credentials: Credentials;
-}): Promise<ServerUpdateItem[]>;
-export interface PublishGroupSummary {
-    publishGroup: string;
-    platforms: string[];
-    commitHash: string;
-    message?: string;
-    createdAt: string;
-    updates: ServerUpdateItem[];
-}
+    cursor?: string;
+    limit?: number;
+}): Promise<ServerUpdatesPage>;
+export declare function fetchPublishGroups({ baseUrl, appId, branch, runtimeVersion, credentials, cursor, limit, }: {
+    baseUrl: string;
+    appId: string;
+    branch: string;
+    runtimeVersion: string;
+    credentials: Credentials;
+    cursor?: string;
+    limit?: number;
+}): Promise<ServerPublishGroupsPage | null>;
 export declare function groupPublishedUpdates(updates: ServerUpdateItem[]): {
     groups: PublishGroupSummary[];
     ungrouped: ServerUpdateItem[];

package/dist/lib/serverUpdates.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.describePublishGroup = exports.groupPublishedUpdates = exports.fetchUpdates = exports.fetchRuntimeVersions = void 0;
+exports.describePublishGroup = exports.groupPublishedUpdates = exports.fetchPublishGroups = exports.fetchUpdates = exports.fetchRuntimeVersions = void 0;
 const auth_1 = require("./auth");
 const fetch_1 = require("./fetch");
 async function fetchRuntimeVersions({ baseUrl, appId, branch, credentials, }) {
@@ -16,8 +16,13 @@ async function fetchRuntimeVersions({ baseUrl, appId, branch, credentials, }) {
     return (await response.json());
 }
 exports.fetchRuntimeVersions = fetchRuntimeVersions;
-async function fetchUpdates({ baseUrl, appId, branch, runtimeVersion, credentials, }) {
-    const response = await (0, fetch_1.fetchWithRetries)(`${baseUrl}/api/apps/${appId}/branch/${branch}/runtimeVersion/${runtimeVersion}/updates`, {
+async function fetchUpdates({ baseUrl, appId, branch, runtimeVersion, credentials, cursor, limit = 20, }) {
+    const url = new URL(`${baseUrl}/api/apps/${encodeURIComponent(appId)}/branch/${encodeURIComponent(branch)}/runtimeVersion/${encodeURIComponent(runtimeVersion)}/updates`);
+    url.searchParams.set('limit', String(limit));
+    if (cursor) {
+        url.searchParams.set('cursor', cursor);
+    }
+    const response = await (0, fetch_1.fetchWithRetries)(url.toString(), {
         headers: {
             ...(0, auth_1.getAuthHeaders)(credentials),
             'use-cli-auth': 'true',
@@ -29,6 +34,29 @@ async function fetchUpdates({ baseUrl, appId, branch, runtimeVersion, credential
     return (await response.json());
 }
 exports.fetchUpdates = fetchUpdates;
+// Publish groups only exist in control-plane mode. A 404 marks group mode as
+// unavailable without requiring a separate capability negotiation request.
+async function fetchPublishGroups({ baseUrl, appId, branch, runtimeVersion, credentials, cursor, limit = 20, }) {
+    const url = new URL(`${baseUrl}/api/apps/${encodeURIComponent(appId)}/branch/${encodeURIComponent(branch)}/runtimeVersion/${encodeURIComponent(runtimeVersion)}/publish-groups`);
+    url.searchParams.set('limit', String(limit));
+    if (cursor) {
+        url.searchParams.set('cursor', cursor);
+    }
+    const response = await (0, fetch_1.fetchWithRetries)(url.toString(), {
+        headers: {
+            ...(0, auth_1.getAuthHeaders)(credentials),
+            'use-cli-auth': 'true',
+        },
+    });
+    if (response.status === 404) {
+        return null;
+    }
+    if (!response.ok) {
+        throw new Error(`Failed to fetch publish groups: ${await response.text()}`);
+    }
+    return (await response.json());
+}
+exports.fetchPublishGroups = fetchPublishGroups;
 // groupPublishedUpdates splits a listing into publish groups (newest first)
 // and the leftover ungrouped updates (older CLIs, stateless servers). Filter
 // out rollback markers before calling if they should not be offered.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eoas",
-  "version": "3.1.2-beta2",
+  "version": "3.1.2-beta4",
   "main": "index.js",
   "scripts": {
     "build": "tsc --project tsconfig.json",