@capawesome/cli 1.14.0 → 2.0.1

package/dist/commands/doctor.js

@@ -1,34 +1,17 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const citty_1 = require("citty");
-const consola_1 = __importDefault(require("consola"));
-const package_json_1 = __importDefault(require("../../package.json"));
-const systeminformation_1 = __importDefault(require("systeminformation"));
-exports.default = (0, citty_1.defineCommand)({
-    meta: {
-        name: 'doctor',
-        description: 'Prints out neccessary information for debugging',
-    },
-    run: () => __awaiter(void 0, void 0, void 0, function* () {
-        const osInfo = yield systeminformation_1.default.osInfo();
-        const versions = yield systeminformation_1.default.versions('npm, node');
-        consola_1.default.box([
+import { defineCommand } from '@robingenz/zli';
+import consola from 'consola';
+import systeminformation from 'systeminformation';
+import pkg from '../../package.json' with { type: 'json' };
+export default defineCommand({
+    description: 'Prints out neccessary information for debugging',
+    action: async (options, args) => {
+        const osInfo = await systeminformation.osInfo();
+        const versions = await systeminformation.versions('npm, node');
+        consola.box([
             `NodeJS version: ${versions.node}`,
             `NPM version: ${versions.npm}`,
-            `CLI version: ${package_json_1.default.version}`,
+            `CLI version: ${pkg.version}`,
             `OS: ${osInfo.distro} ${osInfo.release} ${osInfo.codename ? `(${osInfo.codename})` : ''}`,
         ].join('\n'));
-    }),
+    },
 });

package/dist/commands/doctor.test.js

@@ -0,0 +1,52 @@
+import consola from 'consola';
+import systeminformation from 'systeminformation';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import doctorCommand from './doctor.js';
+// Mock dependencies
+vi.mock('consola');
+vi.mock('systeminformation');
+describe('doctor', () => {
+    const mockConsola = vi.mocked(consola);
+    const mockSystemInformation = vi.mocked(systeminformation);
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should display system information', async () => {
+        const mockOsInfo = {
+            distro: 'macOS',
+            release: '14.0',
+            codename: 'Sonoma',
+        };
+        const mockVersions = {
+            node: '18.17.0',
+            npm: '9.6.7',
+        };
+        mockSystemInformation.osInfo.mockResolvedValue(mockOsInfo);
+        mockSystemInformation.versions.mockResolvedValue(mockVersions);
+        await doctorCommand.action({}, undefined);
+        expect(mockSystemInformation.osInfo).toHaveBeenCalled();
+        expect(mockSystemInformation.versions).toHaveBeenCalledWith('npm, node');
+        expect(mockConsola.box).toHaveBeenCalledWith(expect.stringContaining('NodeJS version: 18.17.0'));
+        expect(mockConsola.box).toHaveBeenCalledWith(expect.stringContaining('NPM version: 9.6.7'));
+        expect(mockConsola.box).toHaveBeenCalledWith(expect.stringContaining('OS: macOS 14.0 (Sonoma)'));
+    });
+    it('should handle OS info without codename', async () => {
+        const mockOsInfo = {
+            distro: 'Ubuntu',
+            release: '22.04',
+            codename: '',
+        };
+        const mockVersions = {
+            node: '20.0.0',
+            npm: '10.0.0',
+        };
+        mockSystemInformation.osInfo.mockResolvedValue(mockOsInfo);
+        mockSystemInformation.versions.mockResolvedValue(mockVersions);
+        await doctorCommand.action({}, undefined);
+        expect(mockConsola.box).toHaveBeenCalledWith(expect.stringContaining('OS: Ubuntu 22.04'));
+        expect(mockConsola.box).toHaveBeenCalledWith(expect.not.stringContaining('()'));
+    });
+});

package/dist/commands/login.js

@@ -1,46 +1,25 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const axios_1 = require("axios");
-const citty_1 = require("citty");
-const consola_1 = __importDefault(require("consola"));
-const open_1 = __importDefault(require("open"));
-const config_1 = __importDefault(require("../services/config"));
-const session_code_1 = __importDefault(require("../services/session-code"));
-const sessions_1 = __importDefault(require("../services/sessions"));
-const users_1 = __importDefault(require("../services/users"));
-const error_1 = require("../utils/error");
-const prompt_1 = require("../utils/prompt");
-const userConfig_1 = __importDefault(require("../utils/userConfig"));
-exports.default = (0, citty_1.defineCommand)({
-    meta: {
-        name: 'login',
-        description: 'Sign in to the Capawesome Cloud Console.',
-    },
-    args: {
-        token: {
-            type: 'string',
-            description: 'Token to use for authentication.',
-        },
-    },
-    run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a;
-        const consoleBaseUrl = yield config_1.default.getValueForKey('CONSOLE_BASE_URL');
-        let sessionIdOrToken = ctx.args.token;
+import configService from '../services/config.js';
+import sessionCodesService from '../services/session-code.js';
+import sessionsService from '../services/sessions.js';
+import usersService from '../services/users.js';
+import { prompt } from '../utils/prompt.js';
+import userConfig from '../utils/user-config.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import { AxiosError } from 'axios';
+import consola from 'consola';
+import open from 'open';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Sign in to the Capawesome Cloud Console.',
+    options: defineOptions(z.object({
+        token: z.string().optional().describe('Token to use for authentication.'),
+    })),
+    action: async (options, args) => {
+        const consoleBaseUrl = await configService.getValueForKey('CONSOLE_BASE_URL');
+        let { token: sessionIdOrToken } = options;
         if (sessionIdOrToken === undefined) {
             // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
-            const authenticationMethod = yield (0, prompt_1.prompt)('How would you like to authenticate Capawesome CLI?', {
+            const authenticationMethod = await prompt('How would you like to authenticate Capawesome CLI?', {
                 type: 'select',
                 options: [
                     { label: 'Login with a web browser', value: 'browser' },
@@ -49,89 +28,89 @@ exports.default = (0, citty_1.defineCommand)({
             });
             if (authenticationMethod === 'browser') {
                 // Create a session code
-                const { id: deviceCode, code: userCode } = yield session_code_1.default.create();
-                consola_1.default.box(`Copy your one-time code: ${userCode.slice(0, 4)}-${userCode.slice(4)}`);
+                const { id: deviceCode, code: userCode } = await sessionCodesService.create();
+                consola.box(`Copy your one-time code: ${userCode.slice(0, 4)}-${userCode.slice(4)}`);
                 // Prompt the user to open the authorization URL in their browser
-                const shouldProceed = yield (0, prompt_1.prompt)(`Select Yes to continue in your browser or No to cancel the authentication.`, {
+                const shouldProceed = await prompt(`Select Yes to continue in your browser or No to cancel the authentication.`, {
                     type: 'confirm',
                     initial: true,
                 });
                 if (!shouldProceed) {
-                    consola_1.default.error('Authentication cancelled.');
+                    consola.error('Authentication cancelled.');
                     process.exit(1);
                 }
                 // Open the authorization URL in the user's default browser
-                consola_1.default.start('Opening browser...');
+                consola.start('Opening browser...');
                 const authorizationUrl = `${consoleBaseUrl}/login/device`;
                 try {
-                    (0, open_1.default)(authorizationUrl);
+                    open(authorizationUrl);
                 }
                 catch (error) {
-                    consola_1.default.warn(`Could not open browser automatically. Please open the following URL manually: ${authorizationUrl}`);
+                    consola.warn(`Could not open browser automatically. Please open the following URL manually: ${authorizationUrl}`);
                 }
                 // Wait for the user to authenticate
-                consola_1.default.start('Waiting for authentication...');
-                const sessionId = yield createSession(deviceCode);
+                consola.start('Waiting for authentication...');
+                const sessionId = await createSession(deviceCode);
                 if (!sessionId) {
-                    consola_1.default.error('Authentication timed out. Please try again.');
+                    consola.error('Authentication timed out. Please try again.');
                     process.exit(1);
                 }
                 sessionIdOrToken = sessionId;
             }
             else {
-                sessionIdOrToken = yield (0, prompt_1.prompt)('Please provide your authentication token:', {
+                sessionIdOrToken = await prompt('Please provide your authentication token:', {
                     type: 'text',
                 });
                 if (!sessionIdOrToken) {
-                    consola_1.default.error('Token must be provided.');
+                    consola.error('Token must be provided.');
                     process.exit(1);
                 }
             }
         }
         else if (sessionIdOrToken.length === 0) {
             // No token provided
-            consola_1.default.error(`Please provide a valid token. You can create a token at ${consoleBaseUrl}/settings/tokens.`);
+            consola.error(`Please provide a valid token. You can create a token at ${consoleBaseUrl}/settings/tokens.`);
             process.exit(1);
         }
         // Sign in with the provided token
-        consola_1.default.start('Signing in...');
-        userConfig_1.default.write({
+        consola.start('Signing in...');
+        userConfig.write({
             token: sessionIdOrToken,
         });
         try {
-            yield users_1.default.me();
-            consola_1.default.success(`Successfully signed in.`);
+            await usersService.me();
+            consola.success(`Successfully signed in.`);
         }
         catch (error) {
-            userConfig_1.default.write({});
-            let message = (0, error_1.getMessageFromUnknownError)(error);
-            if (error instanceof axios_1.AxiosError && ((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401) {
-                message = `Invalid token. Please provide a valid token. You can create a token at ${consoleBaseUrl}/settings/tokens.`;
+            userConfig.write({});
+            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);
+            }
+            else {
+                throw error;
             }
-            consola_1.default.error(message);
-            process.exit(1);
         }
-    }),
+    },
 });
-const createSession = (deviceCode) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
+const createSession = async (deviceCode) => {
     const maxAttempts = 20;
     const interval = 3 * 1000; // 3 seconds
     let attempts = 0;
     let sessionId = null;
     while (attempts < maxAttempts && sessionId === null) {
         try {
-            const response = yield sessions_1.default.create({
+            const response = await sessionsService.create({
                 code: deviceCode,
                 provider: 'code',
             });
             sessionId = response.id;
         }
         catch (error) {
-            if (error instanceof axios_1.AxiosError && ((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 400) {
+            if (error instanceof AxiosError && error.response?.status === 400) {
                 // Session not ready yet, wait and try again
                 attempts++;
-                yield new Promise((resolve) => setTimeout(resolve, interval));
+                await new Promise((resolve) => setTimeout(resolve, interval));
             }
             else {
                 throw error;
@@ -139,4 +118,4 @@ const createSession = (deviceCode) => __awaiter(void 0, void 0, void 0, function
         }
     }
     return sessionId;
-});
+};

package/dist/commands/login.test.js

@@ -0,0 +1,116 @@
+import { DEFAULT_API_BASE_URL, DEFAULT_CONSOLE_BASE_URL } from '../config/consts.js';
+import configService from '../services/config.js';
+import sessionCodesService from '../services/session-code.js';
+import sessionsService from '../services/sessions.js';
+import { prompt } from '../utils/prompt.js';
+import userConfig from '../utils/user-config.js';
+import consola from 'consola';
+import nock from 'nock';
+import open from 'open';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import loginCommand from './login.js';
+// Mock dependencies
+vi.mock('@/utils/user-config.js');
+vi.mock('@/services/session-code.js');
+vi.mock('@/services/sessions.js');
+vi.mock('@/services/config.js');
+vi.mock('open');
+vi.mock('consola');
+vi.mock('@/utils/prompt.js');
+describe('login', () => {
+    const mockUserConfig = vi.mocked(userConfig);
+    const mockSessionCodesService = vi.mocked(sessionCodesService);
+    const mockSessionsService = vi.mocked(sessionsService);
+    const mockConfigService = vi.mocked(configService);
+    const mockOpen = vi.mocked(open);
+    const mockConsola = vi.mocked(consola);
+    const mockPrompt = vi.mocked(prompt);
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockUserConfig.write.mockImplementation(() => { });
+        mockUserConfig.read.mockReturnValue({});
+        // Mock config service to return consistent URLs
+        mockConfigService.getValueForKey.mockImplementation((key) => {
+            if (key === 'CONSOLE_BASE_URL')
+                return Promise.resolve(DEFAULT_CONSOLE_BASE_URL);
+            if (key === 'API_BASE_URL')
+                return Promise.resolve(DEFAULT_API_BASE_URL);
+            return Promise.resolve('');
+        });
+        vi.spyOn(process, 'exit').mockImplementation((code) => {
+            throw new Error(`Process exited with code ${code}`);
+        });
+    });
+    afterEach(() => {
+        nock.cleanAll();
+        vi.restoreAllMocks();
+    });
+    it('should use the provided token for authentication', async () => {
+        const testToken = 'valid-token-123';
+        const options = { token: testToken };
+        // Mock userConfig.read to return our test token after it's written
+        mockUserConfig.read.mockReturnValue({ token: testToken });
+        // Set up nock to intercept the /v1/users/me request
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get('/v1/users/me')
+            .matchHeader('Authorization', `Bearer ${testToken}`)
+            .reply(200, { id: 'user-123', email: 'test@example.com' });
+        await loginCommand.action(options, undefined);
+        expect(mockUserConfig.write).toHaveBeenCalledWith({ token: testToken });
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.success).toHaveBeenCalledWith('Successfully signed in.');
+    });
+    it('should open the browser', async () => {
+        const options = {};
+        mockPrompt
+            .mockResolvedValueOnce('browser') // authentication method
+            .mockResolvedValueOnce(true); // should proceed
+        mockSessionCodesService.create.mockResolvedValue({
+            id: 'device-code-123',
+            code: 'ABCD1234',
+        });
+        mockSessionsService.create.mockResolvedValue({ id: 'session-123' });
+        // Mock userConfig.read to return the session token
+        mockUserConfig.read.mockReturnValue({ token: 'session-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`)
+            .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?', {
+            type: 'select',
+            options: [
+                { label: 'Login with a web browser', value: 'browser' },
+                { label: 'Paste an authentication token', value: 'token' },
+            ],
+        });
+        expect(mockSessionCodesService.create).toHaveBeenCalled();
+        expect(mockConsola.box).toHaveBeenCalledWith('Copy your one-time code: ABCD-1234');
+        expect(mockOpen).toHaveBeenCalledWith(`${DEFAULT_CONSOLE_BASE_URL}/login/device`);
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.success).toHaveBeenCalledWith('Successfully signed in.');
+    });
+    it('should throw an error because the provided token is empty', async () => {
+        const options = { token: '' };
+        // This test should exit early without making API calls since empty token is caught in login logic
+        await expect(loginCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith(`Please provide a valid token. You can create a token at ${DEFAULT_CONSOLE_BASE_URL}/settings/tokens.`);
+    });
+    it('should throw an error because the provided token is invalid', async () => {
+        const invalidToken = 'invalid-token';
+        const options = { token: invalidToken };
+        // Mock userConfig.read to return our invalid token after it's written
+        mockUserConfig.read.mockReturnValue({ token: invalidToken });
+        // Set up nock to intercept the /v1/users/me request and return 401
+        const scope = nock(DEFAULT_API_BASE_URL)
+            .get('/v1/users/me')
+            .matchHeader('Authorization', `Bearer ${invalidToken}`)
+            .reply(401, { message: 'Unauthorized' });
+        await expect(loginCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockUserConfig.write).toHaveBeenCalledWith({ token: invalidToken });
+        expect(mockUserConfig.write).toHaveBeenCalledWith({}); // Clears token on error
+        expect(scope.isDone()).toBe(true);
+        expect(mockConsola.error).toHaveBeenCalledWith(`Invalid token. Please provide a valid token. You can create a token at ${DEFAULT_CONSOLE_BASE_URL}/settings/tokens.`);
+    });
+});

package/dist/commands/logout.js

@@ -1,34 +1,16 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const citty_1 = require("citty");
-const consola_1 = __importDefault(require("consola"));
-const authorization_service_1 = __importDefault(require("../services/authorization-service"));
-const sessions_1 = __importDefault(require("../services/sessions"));
-const userConfig_1 = __importDefault(require("../utils/userConfig"));
-exports.default = (0, citty_1.defineCommand)({
-    meta: {
-        name: 'logout',
-        description: 'Sign out from the Capawesome Cloud Console.',
-    },
-    args: {},
-    run: () => __awaiter(void 0, void 0, void 0, function* () {
-        const token = authorization_service_1.default.getCurrentAuthorizationToken();
+import { defineCommand } from '@robingenz/zli';
+import consola from 'consola';
+import authorizationService from '../services/authorization-service.js';
+import sessionsService from '../services/sessions.js';
+import userConfig from '../utils/user-config.js';
+export default defineCommand({
+    description: 'Sign out from the Capawesome Cloud Console.',
+    action: async (options, args) => {
+        const token = authorizationService.getCurrentAuthorizationToken();
         if (token && !token.startsWith('ca_')) {
-            yield sessions_1.default.delete({ id: token }).catch(() => { });
+            await sessionsService.delete({ id: token }).catch(() => { });
         }
-        userConfig_1.default.write({});
-        consola_1.default.success('Successfully signed out.');
-    }),
+        userConfig.write({});
+        consola.success('Successfully signed out.');
+    },
 });

package/dist/commands/logout.test.js

@@ -0,0 +1,47 @@
+import { DEFAULT_API_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 logoutCommand from './logout.js';
+// Mock dependencies
+vi.mock('@/services/authorization-service.js');
+vi.mock('@/utils/user-config.js');
+vi.mock('consola');
+describe('logout', () => {
+    const mockAuthorizationService = vi.mocked(authorizationService);
+    const mockUserConfig = vi.mocked(userConfig);
+    const mockConsola = vi.mocked(consola);
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockUserConfig.write.mockImplementation(() => { });
+    });
+    afterEach(() => {
+        nock.cleanAll();
+        vi.restoreAllMocks();
+    });
+    it('should delete session and clear user config with session token', async () => {
+        const sessionToken = 'session-123';
+        mockAuthorizationService.getCurrentAuthorizationToken.mockReturnValue(sessionToken);
+        // Set up nock to intercept the DELETE request
+        const scope = nock(DEFAULT_API_BASE_URL).delete('/v1/sessions/session-123').reply(200);
+        await logoutCommand.action({}, undefined);
+        expect(scope.isDone()).toBe(true);
+        expect(mockUserConfig.write).toHaveBeenCalledWith({});
+        expect(mockConsola.success).toHaveBeenCalledWith('Successfully signed out.');
+    });
+    it('should only clear user config with API token', async () => {
+        const apiToken = 'ca_abc123';
+        mockAuthorizationService.getCurrentAuthorizationToken.mockReturnValue(apiToken);
+        await logoutCommand.action({}, undefined);
+        expect(mockUserConfig.write).toHaveBeenCalledWith({});
+        expect(mockConsola.success).toHaveBeenCalledWith('Successfully signed out.');
+    });
+    it('should handle no token gracefully', async () => {
+        mockAuthorizationService.getCurrentAuthorizationToken.mockReturnValue(null);
+        await logoutCommand.action({}, undefined);
+        expect(mockUserConfig.write).toHaveBeenCalledWith({});
+        expect(mockConsola.success).toHaveBeenCalledWith('Successfully signed out.');
+    });
+});

package/dist/commands/manifests/generate.js

@@ -1,51 +1,33 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const citty_1 = require("citty");
-const consola_1 = __importDefault(require("consola"));
-const file_1 = require("../../utils/file");
-const manifest_1 = require("../../utils/manifest");
-const prompt_1 = require("../../utils/prompt");
-exports.default = (0, citty_1.defineCommand)({
-    meta: {
-        description: 'Generate a manifest file.',
-    },
-    args: {
-        path: {
-            type: 'string',
-            description: 'Path to the web assets folder (e.g. `www` or `dist`).',
-        },
-    },
-    run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-        let path = ctx.args.path;
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { z } from 'zod';
+import { fileExistsAtPath } from '../../utils/file.js';
+import { generateManifestJson } from '../../utils/manifest.js';
+import { prompt } from '../../utils/prompt.js';
+export default defineCommand({
+    description: 'Generate a manifest file.',
+    options: defineOptions(z.object({
+        path: z.string().optional().describe('Path to the web assets folder (e.g. `www` or `dist`).'),
+    })),
+    action: async (options, args) => {
+        let path = options.path;
         if (!path) {
-            path = yield (0, prompt_1.prompt)('Enter the path to the web assets folder:', {
+            path = await prompt('Enter the path to the web assets folder:', {
                 type: 'text',
             });
             if (!path) {
-                consola_1.default.error('You must provide a path to the web assets folder.');
+                consola.error('You must provide a path to the web assets folder.');
                 process.exit(1);
             }
         }
         // Check if the path exists
-        const pathExists = yield (0, file_1.fileExistsAtPath)(path);
+        const pathExists = await fileExistsAtPath(path);
         if (!pathExists) {
-            consola_1.default.error(`The path does not exist.`);
+            consola.error(`The path does not exist.`);
             process.exit(1);
         }
         // Generate the manifest file
-        yield (0, manifest_1.generateManifestJson)(path);
-        consola_1.default.success('Manifest file generated.');
-    }),
+        await generateManifestJson(path);
+        consola.success('Manifest file generated.');
+    },
 });

package/dist/commands/manifests/generate.test.js

@@ -0,0 +1,60 @@
+import { fileExistsAtPath } from '../../utils/file.js';
+import { generateManifestJson } from '../../utils/manifest.js';
+import { prompt } from '../../utils/prompt.js';
+import consola from 'consola';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import generateManifestCommand from './generate.js';
+// Mock dependencies
+vi.mock('@/utils/file.js');
+vi.mock('@/utils/manifest.js');
+vi.mock('@/utils/prompt.js');
+vi.mock('consola');
+describe('manifests-generate', () => {
+    const mockFileExistsAtPath = vi.mocked(fileExistsAtPath);
+    const mockGenerateManifestJson = vi.mocked(generateManifestJson);
+    const mockPrompt = vi.mocked(prompt);
+    const mockConsola = vi.mocked(consola);
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.spyOn(process, 'exit').mockImplementation((code) => {
+            throw new Error(`Process exited with code ${code}`);
+        });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should generate manifest with provided path', async () => {
+        const options = { path: './dist' };
+        mockFileExistsAtPath.mockResolvedValue(true);
+        mockGenerateManifestJson.mockResolvedValue(undefined);
+        await generateManifestCommand.action(options, undefined);
+        expect(mockFileExistsAtPath).toHaveBeenCalledWith('./dist');
+        expect(mockGenerateManifestJson).toHaveBeenCalledWith('./dist');
+        expect(mockConsola.success).toHaveBeenCalledWith('Manifest file generated.');
+    });
+    it('should prompt for path when not provided', async () => {
+        const options = {};
+        mockPrompt.mockResolvedValueOnce('./www');
+        mockFileExistsAtPath.mockResolvedValue(true);
+        mockGenerateManifestJson.mockResolvedValue(undefined);
+        await generateManifestCommand.action(options, undefined);
+        expect(mockPrompt).toHaveBeenCalledWith('Enter the path to the web assets folder:', {
+            type: 'text',
+        });
+        expect(mockFileExistsAtPath).toHaveBeenCalledWith('./www');
+        expect(mockGenerateManifestJson).toHaveBeenCalledWith('./www');
+        expect(mockConsola.success).toHaveBeenCalledWith('Manifest file generated.');
+    });
+    it('should handle missing path in prompt', async () => {
+        const options = {};
+        mockPrompt.mockResolvedValueOnce('');
+        await expect(generateManifestCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('You must provide a path to the web assets folder.');
+    });
+    it('should handle nonexistent path', async () => {
+        const options = { path: './nonexistent' };
+        mockFileExistsAtPath.mockResolvedValue(false);
+        await expect(generateManifestCommand.action(options, undefined)).rejects.toThrow('Process exited with code 1');
+        expect(mockConsola.error).toHaveBeenCalledWith('The path does not exist.');
+    });
+});