@capawesome/cli 4.14.0 → 4.16.0

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [4.16.0](https://github.com/capawesome-team/cli/compare/v4.15.0...v4.16.0) (2026-07-12)
+
+
+### Features
+
+* add `apps:builds:share` command and `--share` flag on `apps:builds:create` ([#178](https://github.com/capawesome-team/cli/issues/178)) ([05588c3](https://github.com/capawesome-team/cli/commit/05588c3db4fab2843f54fa1180de9e37c0d9b518))
+
+
+### Bug Fixes
+
+* correct success message when using `--detached` ([#179](https://github.com/capawesome-team/cli/issues/179)) ([33cd33b](https://github.com/capawesome-team/cli/commit/33cd33b5266353fe62b8ba9858f58c7f13dd9e78))
+* run deployment before `--json` output in `apps:builds:create` ([#182](https://github.com/capawesome-team/cli/issues/182)) ([1d693fb](https://github.com/capawesome-team/cli/commit/1d693fb1cafccd02237dd61c94b81e9e62b79f36))
+
+## [4.15.0](https://github.com/capawesome-team/cli/compare/v4.14.0...v4.15.0) (2026-06-23)
+
+
+### Features
+
+* **login:** support the new session token field ([#176](https://github.com/capawesome-team/cli/issues/176)) ([195922d](https://github.com/capawesome-team/cli/commit/195922d60e9a035143f236aeaaeea6e9aa842c52))
+
+
+### Bug Fixes
+
+* **login:** fall back to file storage when keyring write fails ([#177](https://github.com/capawesome-team/cli/issues/177)) ([ec6019d](https://github.com/capawesome-team/cli/commit/ec6019d58476abda2c12646fd434b77636095355))
+
 ## [4.14.0](https://github.com/capawesome-team/cli/compare/v4.13.0...v4.14.0) (2026-06-22)
 
 

package/dist/commands/apps/builds/create.js

@@ -4,6 +4,7 @@ import appBuildsService from '../../../services/app-builds.js';
 import appCertificatesService from '../../../services/app-certificates.js';
 import appEnvironmentsService from '../../../services/app-environments.js';
 import appsService from '../../../services/apps.js';
+import { getAppBuildShareUrls } from '../../../utils/app-build-shares.js';
 import { parseKeyValuePairs } from '../../../utils/app-environments.js';
 import { withAuth } from '../../../utils/auth.js';
 import { createBufferFromPath } from '../../../utils/buffer.js';
@@ -62,6 +63,19 @@ export default defineCommand({
         })
             .optional()
             .describe('The platform for the build. Supported values are `ios`, `android`, and `web`.'),
+        share: z.boolean().optional().describe('Create a public share link for the build after it succeeds.'),
+        shareDescription: z
+            .string()
+            .optional()
+            .describe('Additional information for testers, e.g. what to test. Requires --share.'),
+        shareExpiresInDays: z.coerce
+            .number()
+            .int()
+            .min(1, {
+            message: 'Expires in days must be a positive integer.',
+        })
+            .optional()
+            .describe('Number of days until the share link expires. Requires --share.'),
         stack: z
             .enum(['macos-sequoia', 'macos-tahoe'], {
             message: 'Build stack must be either `macos-sequoia` or `macos-tahoe`.',
@@ -104,6 +118,16 @@ export default defineCommand({
             consola.error('The --detached flag cannot be used with --failure-summary.');
             process.exit(1);
         }
+        // Validate that detached flag cannot be used with share
+        if (options.detached && options.share) {
+            consola.error('The --detached flag cannot be used with --share. Sharing requires waiting for completion.');
+            process.exit(1);
+        }
+        // Validate that share sub-flags cannot be used without share
+        if (!options.share && (options.shareDescription !== undefined || options.shareExpiresInDays !== undefined)) {
+            consola.error('The --share-description and --share-expires-in-days flags require --share.');
+            process.exit(1);
+        }
         // Validate that channel and destination cannot be used together
         if (options.channel && options.destination) {
             consola.error('The --channel and --destination flags cannot be used together.');
@@ -393,11 +417,40 @@ export default defineCommand({
                     filePath: typeof options.zip === 'string' ? options.zip : undefined,
                 });
             }
+            // Create a public share link if requested
+            let share;
+            if (options.share) {
+                const expiresAt = options.shareExpiresInDays !== undefined
+                    ? new Date(Date.now() + options.shareExpiresInDays * 24 * 60 * 60 * 1000).toISOString()
+                    : undefined;
+                const createdShare = await appBuildsService.createShare({
+                    appId,
+                    appBuildId: response.id,
+                    description: options.shareDescription,
+                    expiresAt,
+                });
+                const shareUrls = await getAppBuildShareUrls(createdShare.id);
+                share = {
+                    id: createdShare.id,
+                    url: shareUrls.url,
+                    qrCodeUrl: shareUrls.qrCodeUrl,
+                    expiresAt: createdShare.expiresAt,
+                };
+                if (!json) {
+                    consola.success('Build shared successfully.');
+                    consola.info(`Share URL: ${shareUrls.url}`);
+                }
+            }
+            // Create deployment if channel or destination is set
+            if (options.channel || options.destination) {
+                await (await import('../../../commands/apps/deployments/create.js').then((mod) => mod.default)).action({ appId, buildId: response.id, channel: options.channel, destination: options.destination }, undefined);
+            }
             // Output JSON if json flag is set
             if (json) {
                 console.log(JSON.stringify({
                     id: response.id,
                     numberAsString: response.numberAsString,
+                    ...(share ? { share } : {}),
                 }, null, 2));
             }
         }
@@ -412,13 +465,9 @@ export default defineCommand({
                 consola.info(`Build ID: ${response.id}`);
                 consola.info(`Build Number: ${response.numberAsString}`);
                 consola.info(`Build URL: ${DEFAULT_CONSOLE_BASE_URL}/apps/${appId}/builds/${response.id}`);
-                consola.success(`Build completed successfully.`);
+                consola.success('Build started successfully.');
             }
         }
-        // Create deployment if channel or destination is set
-        if (options.channel || options.destination) {
-            await (await import('../../../commands/apps/deployments/create.js').then((mod) => mod.default)).action({ appId, buildId: response.id, channel: options.channel, destination: options.destination }, undefined);
-        }
     }),
 });
 /**

package/dist/commands/apps/builds/create.test.js

@@ -0,0 +1,121 @@
+import { DEFAULT_API_BASE_URL, DEFAULT_CONSOLE_BASE_URL } from '../../../config/consts.js';
+import authorizationService from '../../../services/authorization-service.js';
+import userConfig from '../../../utils/user-config.js';
+import consola from 'consola';
+import nock from 'nock';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import createCommand from './create.js';
+// Mock dependencies
+vi.mock('@/utils/user-config.js');
+vi.mock('@/utils/prompt.js');
+vi.mock('@/services/authorization-service.js');
+vi.mock('@/utils/job.js');
+vi.mock('consola');
+vi.mock('@/utils/environment.js', () => ({
+    isInteractive: () => false,
+}));
+describe('apps-builds-create', () => {
+    const mockUserConfig = vi.mocked(userConfig);
+    const mockAuthorizationService = vi.mocked(authorizationService);
+    const mockConsola = vi.mocked(consola);
+    const testToken = 'test-token';
+    const appId = '00000000-0000-0000-0000-000000000001';
+    const buildId = '00000000-0000-0000-0000-000000000002';
+    const validAppId = '11111111-1111-4111-8111-111111111111';
+    const shareId = 'share-abc';
+    beforeEach(async () => {
+        vi.clearAllMocks();
+        mockUserConfig.read.mockReturnValue({ token: testToken });
+        mockAuthorizationService.hasAuthorizationToken.mockReturnValue(true);
+        mockAuthorizationService.getCurrentAuthorizationToken.mockReturnValue(testToken);
+        // Mock waitForJobCompletion to resolve immediately as succeeded
+        const jobUtils = await import('../../../utils/job.js');
+        vi.mocked(jobUtils.waitForJobCompletion).mockResolvedValue({
+            id: 'job-1',
+            status: 'succeeded',
+            createdAt: '2024-01-01T00:00:00Z',
+        });
+        vi.spyOn(process, 'exit').mockImplementation((code) => {
+            throw new Error(`Process exited with code ${code}`);
+        });
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        nock.cleanAll();
+        vi.restoreAllMocks();
+    });
+    it('should create a share and merge it into the JSON output', async () => {
+        const options = { appId, platform: 'web', gitRef: 'main', share: true, json: true };
+        const buildScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/builds`)
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, { id: buildId, jobId: 'job-1', numberAsString: '42' });
+        const findScope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/builds/${buildId}`)
+            .query({ relations: 'appBuildArtifacts' })
+            .reply(200, { id: buildId, appBuildArtifacts: [] });
+        const shareScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/builds/${buildId}/shares`, {})
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, {
+            id: shareId,
+            appBuildId: buildId,
+            description: null,
+            expiresAt: null,
+            createdAt: '2024-01-01T00:00:00Z',
+            updatedAt: '2024-01-01T00:00:00Z',
+        });
+        await createCommand.action(options, undefined);
+        expect(buildScope.isDone()).toBe(true);
+        expect(findScope.isDone()).toBe(true);
+        expect(shareScope.isDone()).toBe(true);
+        const url = `${DEFAULT_CONSOLE_BASE_URL}/app-build-shares/${shareId}`;
+        const qrCodeUrl = `${DEFAULT_API_BASE_URL}/v1/qrcodes?content=${encodeURIComponent(url)}&format=png`;
+        expect(console.log).toHaveBeenCalledWith(JSON.stringify({
+            id: buildId,
+            numberAsString: '42',
+            share: { id: shareId, url, qrCodeUrl, expiresAt: null },
+        }, null, 2));
+    });
+    it('should reject --share combined with --detached', async () => {
+        const options = { appId, platform: 'web', gitRef: 'main', share: true, detached: true };
+        await expect(createCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('The --detached flag cannot be used with --share. Sharing requires waiting for completion.');
+    });
+    it('should reject --share-description without --share', async () => {
+        const options = { appId, platform: 'web', gitRef: 'main', shareDescription: 'What to test' };
+        await expect(createCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('The --share-description and --share-expires-in-days flags require --share.');
+    });
+    it('should reject --share-expires-in-days without --share', async () => {
+        const options = { appId, platform: 'web', gitRef: 'main', shareExpiresInDays: 7 };
+        await expect(createCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('The --share-description and --share-expires-in-days flags require --share.');
+    });
+    it('should reject a non-positive shareExpiresInDays value', () => {
+        const schema = createCommand.options?.schema;
+        for (const shareExpiresInDays of [0, -1]) {
+            const result = schema?.safeParse({
+                appId: validAppId,
+                platform: 'web',
+                gitRef: 'main',
+                share: true,
+                shareExpiresInDays,
+            });
+            expect(result?.success).toBe(false);
+            expect(result?.error?.issues[0]?.message).toBe('Expires in days must be a positive integer.');
+        }
+    });
+    it('should accept a positive shareExpiresInDays value', () => {
+        const schema = createCommand.options?.schema;
+        const result = schema?.safeParse({
+            appId: validAppId,
+            platform: 'web',
+            gitRef: 'main',
+            share: true,
+            shareExpiresInDays: 7,
+        });
+        expect(result?.success).toBe(true);
+        expect(result?.data?.shareExpiresInDays).toBe(7);
+    });
+});

package/dist/commands/apps/builds/share.js

@@ -0,0 +1,105 @@
+import appBuildsService from '../../../services/app-builds.js';
+import { getAppBuildShareUrls } from '../../../utils/app-build-shares.js';
+import { withAuth } from '../../../utils/auth.js';
+import { isInteractive } from '../../../utils/environment.js';
+import { prompt, promptAppSelection, promptOrganizationSelection } from '../../../utils/prompt.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Create a public share link for an app build.',
+    options: defineOptions(z.object({
+        appId: z
+            .uuid({
+            message: 'App ID must be a UUID.',
+        })
+            .optional()
+            .describe('App ID the build belongs to.'),
+        buildId: z
+            .uuid({
+            message: 'Build ID must be a UUID.',
+        })
+            .optional()
+            .describe('Build ID to share.'),
+        buildNumber: z.string().optional().describe('Build number to share (e.g., "1", "42").'),
+        description: z.string().optional().describe('Additional information for testers, e.g. what to test.'),
+        expiresInDays: z.coerce
+            .number()
+            .int()
+            .min(1, {
+            message: 'Expires in days must be a positive integer.',
+        })
+            .optional()
+            .describe('Number of days until the share link expires.'),
+        json: z.boolean().optional().describe('Output in JSON format.'),
+    })),
+    action: withAuth(async (options) => {
+        let { appId, buildId } = options;
+        const { buildNumber, description, expiresInDays, json } = options;
+        // Prompt for app ID if not provided
+        if (!appId) {
+            if (!isInteractive()) {
+                consola.error('You must provide an app ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const organizationId = await promptOrganizationSelection();
+            appId = await promptAppSelection(organizationId);
+        }
+        // Convert build number to build ID if provided
+        if (!buildId && buildNumber) {
+            const builds = await appBuildsService.findAll({ appId, numberAsString: buildNumber });
+            if (builds.length === 0) {
+                consola.error(`Build #${buildNumber} not found.`);
+                process.exit(1);
+            }
+            buildId = builds[0]?.id;
+        }
+        // Prompt for build ID if not provided
+        if (!buildId) {
+            if (!isInteractive()) {
+                consola.error('You must provide a build ID when running in non-interactive environment.');
+                process.exit(1);
+            }
+            const builds = await appBuildsService.findAll({ appId });
+            if (builds.length === 0) {
+                consola.error('No builds found for this app.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            buildId = await prompt('Select the build you want to share:', {
+                type: 'select',
+                options: builds.map((build) => ({
+                    label: `Build #${build.numberAsString || build.id} (${build.platform} - ${build.type})`,
+                    value: build.id,
+                })),
+            });
+            if (!buildId) {
+                consola.error('You must select a build to share.');
+                process.exit(1);
+            }
+        }
+        // Ensure the build has succeeded before creating a share
+        const build = await appBuildsService.findOne({ appId, appBuildId: buildId, relations: 'job' });
+        if (build.job?.status !== 'succeeded') {
+            consola.error('The build has not succeeded yet. Only successful builds can be shared.');
+            process.exit(1);
+        }
+        // Compute the expiration date if provided
+        const expiresAt = expiresInDays !== undefined
+            ? new Date(Date.now() + expiresInDays * 24 * 60 * 60 * 1000).toISOString()
+            : undefined;
+        const share = await appBuildsService.createShare({ appId, appBuildId: buildId, description, expiresAt });
+        const { url, qrCodeUrl } = await getAppBuildShareUrls(share.id);
+        if (json) {
+            console.log(JSON.stringify({ id: share.id, url, qrCodeUrl, expiresAt: share.expiresAt }, null, 2));
+        }
+        else {
+            consola.success('Build shared successfully.');
+            consola.info(`Share URL: ${url}`);
+            consola.info(`QR Code URL: ${qrCodeUrl}`);
+            if (share.expiresAt) {
+                consola.info(`Expires At: ${share.expiresAt}`);
+            }
+        }
+    }),
+});

package/dist/commands/apps/builds/share.test.js

@@ -0,0 +1,130 @@
+import { DEFAULT_API_BASE_URL, DEFAULT_CONSOLE_BASE_URL } from '../../../config/consts.js';
+import authorizationService from '../../../services/authorization-service.js';
+import userConfig from '../../../utils/user-config.js';
+import consola from 'consola';
+import nock from 'nock';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import shareCommand from './share.js';
+// Mock dependencies
+vi.mock('@/utils/user-config.js');
+vi.mock('@/utils/prompt.js');
+vi.mock('@/services/authorization-service.js');
+vi.mock('consola');
+vi.mock('@/utils/environment.js', () => ({
+    isInteractive: () => false,
+}));
+describe('apps-builds-share', () => {
+    const mockUserConfig = vi.mocked(userConfig);
+    const mockAuthorizationService = vi.mocked(authorizationService);
+    const mockConsola = vi.mocked(consola);
+    const testToken = 'test-token';
+    const appId = '00000000-0000-0000-0000-000000000001';
+    const buildId = '00000000-0000-0000-0000-000000000002';
+    const validAppId = '11111111-1111-4111-8111-111111111111';
+    const validBuildId = '22222222-2222-4222-8222-222222222222';
+    const shareId = 'share-abc';
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockUserConfig.read.mockReturnValue({ token: testToken });
+        mockAuthorizationService.hasAuthorizationToken.mockReturnValue(true);
+        mockAuthorizationService.getCurrentAuthorizationToken.mockReturnValue(testToken);
+        vi.spyOn(process, 'exit').mockImplementation((code) => {
+            throw new Error(`Process exited with code ${code}`);
+        });
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        nock.cleanAll();
+        vi.restoreAllMocks();
+    });
+    it('should create a share and output the exact JSON shape', async () => {
+        const options = { appId, buildId, json: true };
+        const buildScope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/builds/${buildId}`)
+            .query({ relations: 'job' })
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: buildId, job: { id: 'job-1', status: 'succeeded' } });
+        const shareScope = nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/builds/${buildId}/shares`, {})
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(201, {
+            id: shareId,
+            appBuildId: buildId,
+            description: null,
+            expiresAt: null,
+            createdAt: '2024-01-01T00:00:00Z',
+            updatedAt: '2024-01-01T00:00:00Z',
+        });
+        await shareCommand.action(options, undefined);
+        expect(buildScope.isDone()).toBe(true);
+        expect(shareScope.isDone()).toBe(true);
+        const url = `${DEFAULT_CONSOLE_BASE_URL}/app-build-shares/${shareId}`;
+        const qrCodeUrl = `${DEFAULT_API_BASE_URL}/v1/qrcodes?content=${encodeURIComponent(url)}&format=png`;
+        expect(console.log).toHaveBeenCalledWith(JSON.stringify({ id: shareId, url, qrCodeUrl, expiresAt: null }, null, 2));
+        expect(mockConsola.success).not.toHaveBeenCalled();
+    });
+    it('should compute expiresAt from expiresInDays', async () => {
+        const expiresInDays = 7;
+        const options = { appId, buildId, expiresInDays, json: true };
+        nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/builds/${buildId}`)
+            .query({ relations: 'job' })
+            .reply(200, { id: buildId, job: { id: 'job-1', status: 'succeeded' } });
+        let capturedBody = {};
+        nock(DEFAULT_API_BASE_URL)
+            .post(`/v1/apps/${appId}/builds/${buildId}/shares`, (body) => {
+            capturedBody = body;
+            return true;
+        })
+            .reply(201, {
+            id: shareId,
+            appBuildId: buildId,
+            description: null,
+            expiresAt: capturedBody.expiresAt ?? null,
+            createdAt: '2024-01-01T00:00:00Z',
+            updatedAt: '2024-01-01T00:00:00Z',
+        });
+        const before = Date.now();
+        await shareCommand.action(options, undefined);
+        const after = Date.now();
+        expect(capturedBody.expiresAt).toBeDefined();
+        const expiresAtMs = new Date(capturedBody.expiresAt).getTime();
+        const millisPerDay = 24 * 60 * 60 * 1000;
+        expect(expiresAtMs).toBeGreaterThanOrEqual(before + expiresInDays * millisPerDay);
+        expect(expiresAtMs).toBeLessThanOrEqual(after + expiresInDays * millisPerDay);
+    });
+    it('should error when the build has not succeeded', async () => {
+        const options = { appId, buildId, json: true };
+        const buildScope = nock(DEFAULT_API_BASE_URL)
+            .get(`/v1/apps/${appId}/builds/${buildId}`)
+            .query({ relations: 'job' })
+            .reply(200, { id: buildId, job: { id: 'job-1', status: 'in_progress' } });
+        await expect(shareCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(buildScope.isDone()).toBe(true);
+        expect(mockConsola.error).toHaveBeenCalledWith('The build has not succeeded yet. Only successful builds can be shared.');
+    });
+    it('should require app ID in non-interactive mode', async () => {
+        const options = { buildId };
+        await expect(shareCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('You must provide an app ID when running in non-interactive environment.');
+    });
+    it('should require build ID in non-interactive mode', async () => {
+        const options = { appId };
+        await expect(shareCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('You must provide a build ID when running in non-interactive environment.');
+    });
+    it('should reject a non-positive expiresInDays value', () => {
+        const schema = shareCommand.options?.schema;
+        for (const expiresInDays of [0, -1]) {
+            const result = schema?.safeParse({ appId: validAppId, buildId: validBuildId, expiresInDays });
+            expect(result?.success).toBe(false);
+            expect(result?.error?.issues[0]?.message).toBe('Expires in days must be a positive integer.');
+        }
+    });
+    it('should accept a positive expiresInDays value', () => {
+        const schema = shareCommand.options?.schema;
+        const result = schema?.safeParse({ appId: validAppId, buildId: validBuildId, expiresInDays: 7 });
+        expect(result?.success).toBe(true);
+        expect(result?.data?.expiresInDays).toBe(7);
+    });
+});

package/dist/commands/login.js

@@ -19,6 +19,8 @@ export default defineCommand({
     action: async (options, args) => {
         const consoleBaseUrl = await configService.getValueForKey('CONSOLE_BASE_URL');
         let { token: sessionIdOrToken } = options;
+        // The non-secret session id, only set when authenticating via the browser.
+        let sessionId;
         if (sessionIdOrToken === undefined) {
             if (!isInteractive()) {
                 consola.error('You must provide a token when running in non-interactive environment.');
@@ -56,12 +58,13 @@ export default defineCommand({
                 }
                 // Wait for the user to authenticate
                 consola.start('Waiting for authentication...');
-                const sessionId = await createSession(deviceCode);
-                if (!sessionId) {
+                const session = await createSession(deviceCode);
+                if (!session) {
                     consola.error('Authentication timed out. Please try again.');
                     process.exit(1);
                 }
-                sessionIdOrToken = sessionId;
+                sessionId = session.id;
+                sessionIdOrToken = session.token;
             }
             else {
                 consola.info(`You can create a token at ${consoleBaseUrl}/settings/tokens.`);
@@ -84,17 +87,20 @@ export default defineCommand({
         consola.start('Signing in...');
         // Drop the previous user ID but keep other flags,
         // so a crash during sign-in isn't attributed to the previous account
-        const { token: _previousToken, userId: _previousUserId, ...persistentConfig } = userConfig.read();
-        userConfig.write(persistentConfig);
+        const { sessionId: _previousSessionId, token: _previousToken, userId: _previousUserId, ...persistentConfig } = userConfig.read();
+        // Persist the non-secret session id right away, so a crash during sign-in
+        // still lets logout delete the correct server session.
+        userConfig.write({ ...persistentConfig, ...(sessionId ? { sessionId } : {}) });
         credentialStore.setToken(sessionIdOrToken);
         try {
             const user = await usersService.me();
-            userConfig.write({ ...persistentConfig, userId: user.id });
+            userConfig.write({ ...persistentConfig, userId: user.id, ...(sessionId ? { sessionId } : {}) });
             consola.success(`Successfully signed in.`);
         }
         catch (error) {
-            // Clear the credentials on failure while preserving the other flags
+            // Clear the credentials and session id on failure while preserving the other flags
             credentialStore.deleteToken();
+            userConfig.write(persistentConfig);
             if (error instanceof AxiosError && error.response?.status === 401) {
                 consola.error(`Invalid token. Please provide a valid token. You can create a token at ${consoleBaseUrl}/settings/tokens.`);
                 process.exit(1);
@@ -109,14 +115,13 @@ const createSession = async (deviceCode) => {
     const maxAttempts = 20;
     const interval = 3 * 1000; // 3 seconds
     let attempts = 0;
-    let sessionId = null;
-    while (attempts < maxAttempts && sessionId === null) {
+    let session = null;
+    while (attempts < maxAttempts && session === null) {
         try {
-            const response = await sessionsService.create({
+            session = await sessionsService.create({
                 code: deviceCode,
                 provider: 'code',
             });
-            sessionId = response.id;
         }
         catch (error) {
             if (error instanceof AxiosError && error.response?.status === 400) {
@@ -129,5 +134,5 @@ const createSession = async (deviceCode) => {
             }
         }
     }
-    return sessionId;
+    return session;
 };

package/dist/commands/login.test.js

@@ -98,13 +98,13 @@ describe('login', () => {
             id: 'device-code-123',
             code: 'ABCD1234',
         });
-        mockSessionsService.create.mockResolvedValue({ id: 'session-123' });
+        mockSessionsService.create.mockResolvedValue({ id: 'session-123', token: 'session-token-123' });
         // Mock credentialStore.getToken to return the session token
-        mockCredentialStore.getToken.mockReturnValue('session-123');
+        mockCredentialStore.getToken.mockReturnValue('session-token-123');
         // Set up nock to intercept the /v1/users/me request
         const scope = nock(DEFAULT_API_BASE_URL)
             .get('/v1/users/me')
-            .matchHeader('Authorization', `Bearer session-123`)
+            .matchHeader('Authorization', `Bearer session-token-123`)
             .reply(200, { id: 'user-123', email: 'test@example.com' });
         await loginCommand.action(options, undefined);
         expect(mockPrompt).toHaveBeenCalledWith('How would you like to authenticate Capawesome CLI?', {
@@ -117,6 +117,10 @@ describe('login', () => {
         expect(mockSessionCodesService.create).toHaveBeenCalled();
         expect(mockConsola.box).toHaveBeenCalledWith('Copy your one-time code: ABCD-1234');
         expect(mockOpen).toHaveBeenCalledWith(`${DEFAULT_CONSOLE_BASE_URL}/login/device`);
+        // The token (not the id) must be stored as the credential
+        expect(mockCredentialStore.setToken).toHaveBeenCalledWith('session-token-123');
+        // The non-secret session id must be persisted so logout can delete the session
+        expect(mockUserConfig.write).toHaveBeenLastCalledWith({ userId: 'user-123', sessionId: 'session-123' });
         expect(scope.isDone()).toBe(true);
         expect(mockConsola.success).toHaveBeenCalledWith('Successfully signed in.');
     });

package/dist/commands/logout.js

@@ -8,12 +8,14 @@ export default defineCommand({
     description: 'Sign out from the Capawesome Cloud Console.',
     action: async (options, args) => {
         const token = authorizationService.getCurrentAuthorizationToken();
+        // Clear the session id and user ID but keep other flags (e.g. the telemetry notice).
+        const { sessionId, token: _token, userId: _userId, ...persistentConfig } = userConfig.read();
         if (token && !token.startsWith('ca_')) {
-            await sessionsService.delete({ id: token }).catch(() => { });
+            // Delete by the stored session id. Fall back to the token for sessions
+            // created before the token/id split, whose token equals the id.
+            await sessionsService.delete({ id: sessionId ?? token }).catch(() => { });
         }
         credentialStore.deleteToken();
-        // Clear the user ID but keep other flags (e.g. the telemetry notice).
-        const { token: _token, userId: _userId, ...persistentConfig } = userConfig.read();
         userConfig.write(persistentConfig);
         consola.success('Successfully signed out.');
     },

package/dist/commands/logout.test.js

@@ -36,6 +36,17 @@ describe('logout', () => {
         expect(mockCredentialStore.deleteToken).toHaveBeenCalled();
         expect(mockConsola.success).toHaveBeenCalledWith('Successfully signed out.');
     });
+    it('should delete the session by its stored id when available', async () => {
+        mockAuthorizationService.getCurrentAuthorizationToken.mockReturnValue('session-token-xyz');
+        mockUserConfig.read.mockReturnValue({ sessionId: 'session-id-abc', token: 'session-token-xyz', userId: 'user-1' });
+        // The session must be deleted by its id, not by the token
+        const scope = nock(DEFAULT_API_BASE_URL).delete('/v1/sessions/session-id-abc').reply(200);
+        await logoutCommand.action({}, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockCredentialStore.deleteToken).toHaveBeenCalled();
+        // The session id and other sensitive fields must be cleared from the config
+        expect(mockUserConfig.write).toHaveBeenCalledWith({});
+    });
     it('should only clear credentials with API token', async () => {
         const apiToken = 'ca_abc123';
         mockAuthorizationService.getCurrentAuthorizationToken.mockReturnValue(apiToken);

package/dist/index.js

@@ -36,6 +36,7 @@ const config = defineConfig({
         'apps:builds:get': await import('./commands/apps/builds/get.js').then((mod) => mod.default),
         'apps:builds:list': await import('./commands/apps/builds/list.js').then((mod) => mod.default),
         'apps:builds:logs': await import('./commands/apps/builds/logs.js').then((mod) => mod.default),
+        'apps:builds:share': await import('./commands/apps/builds/share.js').then((mod) => mod.default),
         'apps:builds:download': await import('./commands/apps/builds/download.js').then((mod) => mod.default),
         'apps:bundles:create': await import('./commands/apps/bundles/create.js').then((mod) => mod.default),
         'apps:bundles:delete': await import('./commands/apps/bundles/delete.js').then((mod) => mod.default),

package/dist/services/app-builds.js

@@ -14,6 +14,15 @@ class AppBuildsServiceImpl {
         });
         return response.data;
     }
+    async createShare(dto) {
+        const { appId, appBuildId, ...bodyData } = dto;
+        const response = await this.httpClient.post(`/v1/apps/${appId}/builds/${appBuildId}/shares`, bodyData, {
+            headers: {
+                Authorization: `Bearer ${authorizationService.getCurrentAuthorizationToken()}`,
+            },
+        });
+        return response.data;
+    }
     async findAll(dto) {
         const params = {};
         if (dto.limit !== undefined) {

package/dist/utils/app-build-shares.js

@@ -0,0 +1,11 @@
+import configService from '../services/config.js';
+/**
+ * Build the public share page URL and the corresponding QR code image URL for an app build share.
+ */
+export const getAppBuildShareUrls = async (shareId) => {
+    const consoleBaseUrl = await configService.getValueForKey('CONSOLE_BASE_URL');
+    const apiBaseUrl = await configService.getValueForKey('API_BASE_URL');
+    const url = `${consoleBaseUrl}/app-build-shares/${shareId}`;
+    const qrCodeUrl = `${apiBaseUrl}/v1/qrcodes?content=${encodeURIComponent(url)}&format=png`;
+    return { url, qrCodeUrl };
+};

package/dist/utils/credential-store.js

@@ -9,32 +9,49 @@ const ACCOUNT_NAME = 'token';
  * (e.g. headless CI environments without a keyring backend).
  */
 class CredentialStoreImpl {
-    keyringAvailable = null;
+    // Set once any keyring operation fails (e.g. a headless CI environment with a
+    // present but unusable Secret Service backend). From then on the file token is
+    // the single source of truth for the rest of the process, so reads don't
+    // return a stale keyring token after a failed write.
+    keyringDisabled = false;
     getToken() {
-        if (!this.isKeyringAvailable()) {
-            return userConfig.read().token ?? null;
-        }
-        const token = this.createEntry().getPassword();
-        if (token) {
-            return token;
+        if (!this.keyringDisabled) {
+            try {
+                const token = this.createEntry().getPassword();
+                if (token) {
+                    return token;
+                }
+                return this.migrateFileToken();
+            }
+            catch {
+                this.keyringDisabled = true;
+            }
         }
-        return this.migrateFileToken();
+        return userConfig.read().token ?? null;
     }
     setToken(token) {
-        if (!this.isKeyringAvailable()) {
-            this.writeFileToken(token);
-            return;
+        if (!this.keyringDisabled) {
+            try {
+                this.createEntry().setPassword(token);
+                this.clearFileToken();
+                return;
+            }
+            catch {
+                this.keyringDisabled = true;
+            }
         }
-        this.createEntry().setPassword(token);
-        this.clearFileToken();
+        this.writeFileToken(token);
     }
     deleteToken() {
-        if (this.isKeyringAvailable()) {
+        if (!this.keyringDisabled) {
             try {
                 this.createEntry().deletePassword();
             }
             catch {
-                // Ignore errors when there is no credential to delete.
+                // The deletion throws when there is no credential to delete, but also
+                // when the keyring cannot be mutated. Disable the keyring so a stale
+                // token can't be read back after the file token has been cleared.
+                this.keyringDisabled = true;
             }
         }
         this.clearFileToken();
@@ -42,20 +59,6 @@ class CredentialStoreImpl {
     createEntry() {
         return new Entry(SERVICE_NAME, ACCOUNT_NAME);
     }
-    isKeyringAvailable() {
-        if (this.keyringAvailable === null) {
-            try {
-                // Probe the backend with a read. This throws if no keyring backend is
-                // available, but returns null for a missing credential.
-                this.createEntry().getPassword();
-                this.keyringAvailable = true;
-            }
-            catch {
-                this.keyringAvailable = false;
-            }
-        }
-        return this.keyringAvailable;
-    }
     /**
      * Moves a token stored in the plaintext config file into the keyring and
      * removes the plaintext copy. Returns the migrated token or null.

package/dist/utils/credential-store.test.js

@@ -28,7 +28,7 @@ describe('credentialStore', () => {
         vi.resetModules();
         mockRead.mockReturnValue({});
     });
-    describe('when the keyring is available', () => {
+    describe('when the keyring works', () => {
         beforeEach(() => {
             mockGetPassword.mockReturnValue(null);
         });
@@ -55,30 +55,66 @@ describe('credentialStore', () => {
             expect(mockSetPassword).toHaveBeenCalledWith('new-token');
             expect(mockWrite).toHaveBeenCalledWith({ userId: 'user-1' });
         });
+        it('should fall back to the config file when the keyring write fails', async () => {
+            mockRead.mockReturnValue({ userId: 'user-1' });
+            mockSetPassword.mockImplementation(() => {
+                throw new Error('Platform failure: Unknown(38)');
+            });
+            const credentialStore = await loadCredentialStore();
+            credentialStore.setToken('new-token');
+            expect(mockSetPassword).toHaveBeenCalledWith('new-token');
+            expect(mockWrite).toHaveBeenCalledWith({ userId: 'user-1', token: 'new-token' });
+        });
+        it('should read the file token after a keyring write failure even when a stale keyring token exists', async () => {
+            mockGetPassword.mockReturnValue('stale-keyring-token');
+            mockSetPassword.mockImplementation(() => {
+                throw new Error('Platform failure: Unknown(38)');
+            });
+            mockRead.mockReturnValue({ token: 'new-token' });
+            const credentialStore = await loadCredentialStore();
+            credentialStore.setToken('new-token');
+            expect(credentialStore.getToken()).toBe('new-token');
+        });
         it('should delete the token from the keyring', async () => {
             const credentialStore = await loadCredentialStore();
             credentialStore.deleteToken();
             expect(mockDeletePassword).toHaveBeenCalled();
         });
+        it('should not read a stale keyring token after a keyring delete failure', async () => {
+            mockGetPassword.mockReturnValue('stale-keyring-token');
+            mockDeletePassword.mockImplementation(() => {
+                throw new Error('Platform failure: Unknown(38)');
+            });
+            const credentialStore = await loadCredentialStore();
+            credentialStore.deleteToken();
+            expect(credentialStore.getToken()).toBeNull();
+        });
     });
     describe('when the keyring is unavailable', () => {
         beforeEach(() => {
-            mockGetPassword.mockImplementation(() => {
+            const throwNoBackend = () => {
                 throw new Error('no keyring backend');
-            });
+            };
+            mockGetPassword.mockImplementation(throwNoBackend);
+            mockSetPassword.mockImplementation(throwNoBackend);
+            mockDeletePassword.mockImplementation(throwNoBackend);
         });
         it('should return the token from the config file', async () => {
             mockRead.mockReturnValue({ token: 'file-token' });
             const credentialStore = await loadCredentialStore();
             expect(credentialStore.getToken()).toBe('file-token');
-            expect(mockSetPassword).not.toHaveBeenCalled();
         });
         it('should store the token in the config file while preserving other fields', async () => {
             mockRead.mockReturnValue({ userId: 'user-1' });
             const credentialStore = await loadCredentialStore();
             credentialStore.setToken('file-token');
             expect(mockWrite).toHaveBeenCalledWith({ userId: 'user-1', token: 'file-token' });
-            expect(mockSetPassword).not.toHaveBeenCalled();
+        });
+        it('should clear the file token without throwing when deleting', async () => {
+            mockRead.mockReturnValue({ token: 'file-token', userId: 'user-1' });
+            const credentialStore = await loadCredentialStore();
+            expect(() => credentialStore.deleteToken()).not.toThrow();
+            expect(mockWrite).toHaveBeenCalledWith({ userId: 'user-1' });
         });
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capawesome/cli",
-  "version": "4.14.0",
+  "version": "4.16.0",
   "description": "The Capawesome Cloud Command Line Interface (CLI) to manage Live Updates and more.",
   "type": "module",
   "scripts": {