@juuno-sdk/cli 1.0.12 → 2.0.0

package/dist/cli/src/deploy/index.js

@@ -1,78 +1,142 @@
 import { readFileSync, existsSync, readdirSync, statSync, realpathSync, } from 'fs';
-import { join, relative } from 'path';
+import { isAbsolute, join, relative } from 'path';
 import JSZip from 'jszip';
 import { getAuthToken, getApiUrl } from '../auth/index.js';
+import { getErrorMessage } from '../utils/error.js';
+import { wrapError } from '../utils/api.js';
+import { isRecord } from '../utils/is-record.js';
 /**
  * Fetches the currently deployed version of an app.
- * Returns null if the app doesn't exist yet.
+ * Returns null if the app doesn't exist yet, or on any error. the caller
+ * treats null as "no current version" so deploys can proceed when the
+ * app-info endpoint is briefly unreachable.
  */
 async function fetchDeployedVersion(token, appId, apiUrl) {
-    const infoUrl = `${apiUrl}/api/v1/developer/apps/${appId}`;
     try {
-        const response = await fetch(infoUrl, {
+        const response = await fetch(`${apiUrl}/api/v1/developer/apps/${appId}`, {
             method: 'GET',
             headers: {
                 Authorization: `Bearer ${token}`,
                 Accept: 'application/json',
             },
         });
-        // App doesn't exist yet - that's fine for first deploy.
-        if (response.status === 404) {
-            return null;
-        }
         if (!response.ok) {
-            // Non-404 errors - log but don't block deploy.
+            // 404 = app doesn't exist yet (first deploy); other errors don't block.
             return null;
         }
         const data = (await response.json());
-        if (!data.success || !data.data) {
-            return null;
-        }
-        return data.data.version ?? null;
+        return data.success && data.data ? (data.data.version ?? null) : null;
     }
     catch {
-        // Network errors - don't block deploy.
+        // Network errors. don't block deploy.
         return null;
     }
 }
+/** Narrows a hand-written manifest value before it reaches array operations. */
+export function isArrayOfStrings(value) {
+    return (Array.isArray(value) && value.every((item) => typeof item === 'string'));
+}
+/** Root-level JSON that is not the manifest is a locale file by convention. */
+function listBundledLocales(buildDir) {
+    return readdirSync(buildDir, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+        .map((entry) => entry.name)
+        .filter((name) => name !== 'manifest.json')
+        .map((name) => name.replace(/\.json$/, ''))
+        .sort();
+}
+/**
+ * Check a `translations` declaration against the locale files a bundle
+ * actually carries, returning the problem or null when they agree.
+ *
+ * Both directions are errors, because both are silent at runtime: a declared
+ * locale with no file makes the host request one that will 404, and a file
+ * nobody declared is never requested at all. English is rejected outright,
+ * since it ships inside the config bundle and never on the CDN.
+ */
+export function checkTranslations(declared, bundled) {
+    if (declared.includes('en')) {
+        return ('Invalid manifest.json - "translations" must not list "en". English ' +
+            'is compiled into your config entry as its `en` export, and is never ' +
+            'fetched.');
+    }
+    if (bundled.includes('en')) {
+        return ('en.json must not be in the build. English belongs in the config ' +
+            'bundle via `export { en }`, and a copy on the CDN is never ' +
+            'requested. Narrow your copy target to `i18n/!(en).json`.');
+    }
+    const missing = declared.filter((locale) => !bundled.includes(locale));
+    if (missing.length > 0) {
+        return (`Declared in "translations" but not in the build: ${missing.join(', ')}. ` +
+            'Every declared locale must ship a <locale>.json at the bundle root, ' +
+            'or the host will request one that does not exist.');
+    }
+    const undeclared = bundled.filter((locale) => !declared.includes(locale));
+    if (undeclared.length > 0) {
+        return (`In the build but not declared in "translations": ${undeclared.join(', ')}. ` +
+            'An undeclared locale is never requested, so these ship to nobody.');
+    }
+    return null;
+}
+/**
+ * Resolve a real path under a base directory. Returns 'unresolvable' when
+ * realpathSync throws (broken symlink, missing target), 'escapes' when the
+ * resolved path lives outside base (traversal attempt), or the resolved
+ * path string when safe to use.
+ *
+ * Containment uses path.relative + isAbsolute, not startsWith, so a base
+ * like /tmp/dist doesn't accidentally accept /tmp/dist-evil/secret.txt.
+ */
+function safeResolveWithinBase(fullPath, base) {
+    let resolved;
+    try {
+        resolved = realpathSync(fullPath);
+    }
+    catch {
+        return 'unresolvable';
+    }
+    const rel = relative(base, resolved);
+    if (isAbsolute(rel) || rel.startsWith('..')) {
+        return 'escapes';
+    }
+    return resolved;
+}
 /**
  * Creates a zip bundle from the build directory.
  * Recursively includes all files while protecting against path traversal.
  */
 async function createZipBundle(buildDir) {
-    const zip = new JSZip();
-    const resolvedBuildDir = realpathSync(buildDir);
-    function addFilesRecursively(dir, zipPath) {
-        const entries = readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = join(dir, entry.name);
-            const entryZipPath = zipPath ? `${zipPath}/${entry.name}` : entry.name;
-            // Resolve symlinks and verify the file is within buildDir.
-            let resolvedPath;
-            try {
-                resolvedPath = realpathSync(fullPath);
-            }
-            catch {
-                // Skip files that can't be resolved (broken symlinks, etc.).
-                console.warn(`   ⚠ Skipping unresolvable path: ${entry.name}`);
-                continue;
-            }
-            // Protect against path traversal attacks.
-            if (!resolvedPath.startsWith(resolvedBuildDir)) {
-                console.warn(`   ⚠ Skipping path outside build directory: ${entry.name}`);
-                continue;
-            }
-            if (entry.isDirectory()) {
-                addFilesRecursively(fullPath, entryZipPath);
-            }
-            else if (entry.isFile() || entry.isSymbolicLink()) {
-                const content = readFileSync(resolvedPath);
-                zip.file(entryZipPath, content);
+    try {
+        const zip = new JSZip();
+        const resolvedBuildDir = realpathSync(buildDir);
+        function addFilesRecursively(dir, zipPath) {
+            for (const entry of readdirSync(dir, { withFileTypes: true })) {
+                const fullPath = join(dir, entry.name);
+                const entryZipPath = zipPath ? `${zipPath}/${entry.name}` : entry.name;
+                const resolved = safeResolveWithinBase(fullPath, resolvedBuildDir);
+                if (resolved === 'unresolvable') {
+                    console.warn(`   ⚠ Skipping unresolvable path: ${entry.name}`);
+                    continue;
+                }
+                if (resolved === 'escapes') {
+                    console.warn(`   ⚠ Skipping path outside build directory: ${entry.name}`);
+                    continue;
+                }
+                if (entry.isDirectory()) {
+                    addFilesRecursively(fullPath, entryZipPath);
+                    continue;
+                }
+                if (entry.isFile() || entry.isSymbolicLink()) {
+                    zip.file(entryZipPath, readFileSync(resolved));
+                }
             }
         }
+        addFilesRecursively(resolvedBuildDir, '');
+        return await zip.generateAsync({ type: 'nodebuffer' });
+    }
+    catch (error) {
+        throw wrapError('Failed to create bundle', error);
     }
-    addFilesRecursively(resolvedBuildDir, '');
-    return await zip.generateAsync({ type: 'nodebuffer' });
 }
 /**
  * Uploads the app bundle to the developer API.
@@ -80,7 +144,12 @@ async function createZipBundle(buildDir) {
 async function uploadBundle(token, zipBuffer, apiUrl) {
     const uploadUrl = `${apiUrl}/api/v1/developer/apps/upload`;
     const formData = new FormData();
-    const blob = new Blob([zipBuffer], { type: 'application/zip' });
+    // @types/node 26 makes Buffer generic over ArrayBufferLike, which BlobPart
+    // rejects because it could be a SharedArrayBuffer. JSZip's 'nodebuffer'
+    // output is always backed by a plain ArrayBuffer, so narrowing is sound.
+    const blob = new Blob([zipBuffer], {
+        type: 'application/zip',
+    });
     formData.append('app_bundle', blob, 'app.zip');
     try {
         const response = await fetch(uploadUrl, {
@@ -102,97 +171,84 @@ async function uploadBundle(token, zipBuffer, apiUrl) {
         return data;
     }
     catch (error) {
-        if (error instanceof Error) {
-            throw new Error(`Upload failed: ${error.message}`);
-        }
-        throw new Error('Upload failed: Unknown error');
+        throw wrapError('Upload failed', error);
     }
 }
 /**
- * Deploys an external app to the Juuno platform.
+ * Read and validate the manifest.json from a build directory. Throws with
+ * actionable messages when the build is missing, the manifest is missing,
+ * or the manifest is malformed.
  */
-export async function deployApp(options) {
-    const buildDir = options.buildDir;
-    console.log('📦 Juuno CLI - Deploy');
-    console.log('');
+function loadAndValidateManifest(buildDir) {
     if (!existsSync(buildDir)) {
-        console.error(`❌ Build directory not found: ${buildDir}`);
-        console.error('   Run your build command first (e.g., npm run build)');
-        process.exit(1);
+        throw new Error(`Build directory not found: ${buildDir}\n   Run your build command first (e.g., npm run build)`);
     }
     const manifestPath = join(buildDir, 'manifest.json');
     if (!existsSync(manifestPath)) {
-        console.error(`❌ manifest.json not found in ${buildDir}`);
-        console.error('   Your build should generate a manifest.json file');
-        process.exit(1);
+        throw new Error(`manifest.json not found in ${buildDir}\n   Your build should generate a manifest.json file`);
     }
-    const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
-    if (!manifest.id || !manifest.version || !manifest.name) {
-        console.error('❌ Invalid manifest.json - missing required fields (id, version, name)');
-        process.exit(1);
-    }
-    console.log(`   App: ${manifest.name}`);
-    console.log(`   Version: ${manifest.version}`);
-    console.log(`   ID: ${manifest.id}`);
-    console.log('');
-    const apiUrl = getApiUrl(options);
-    console.log('🔑 Authenticating...');
-    let token;
+    let parsed;
     try {
-        token = await getAuthToken(options);
-        console.log('   ✓ Authenticated');
-        console.log('');
+        parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
     }
     catch (error) {
-        console.error(`❌ ${error instanceof Error ? error.message : String(error)}`);
-        process.exit(1);
+        throw new Error(`Invalid manifest.json in ${buildDir}: ${getErrorMessage(error)}`);
     }
-    // Check if this version is already deployed.
-    console.log('🔍 Checking deployed version...');
-    const deployedVersion = await fetchDeployedVersion(token, manifest.id, apiUrl);
-    if (deployedVersion !== null && deployedVersion === manifest.version) {
-        if (options.skipIfDeployed) {
-            console.log('');
-            console.log(`ℹ️  ${manifest.name}@${manifest.version} already deployed, skipping.`);
-            console.log('');
-            return;
-        }
-        console.error('');
-        console.error(`❌ Version ${manifest.version} is already deployed for '${manifest.name}'`);
-        console.error('');
-        console.error('   Versions are immutable. Bump the version in your manifest and try again.');
-        console.error('');
-        process.exit(1);
+    if (!isRecord(parsed)) {
+        throw new Error(`Invalid manifest.json in ${buildDir}: expected a JSON object`);
     }
-    if (deployedVersion !== null) {
-        console.log(`   Current: ${deployedVersion} → New: ${manifest.version}`);
+    const manifest = parsed;
+    if (!manifest.id || !manifest.version || !manifest.name) {
+        throw new Error('Invalid manifest.json - missing required fields (id, version, name)');
     }
-    else {
-        console.log('   First deploy for this app');
+    if (!manifest.sdk_version || !/^\d+\.\d+$/.test(manifest.sdk_version)) {
+        throw new Error('Invalid manifest.json - "sdk_version" must be the @juuno-sdk/app-sdk ' +
+            'major.minor this app is built against, e.g. "2.0". The backend ' +
+            'records it on the release and serves the release only to players ' +
+            'that implement it.');
     }
-    console.log('');
-    console.log('📁 Creating bundle...');
-    let zipBuffer;
-    try {
-        zipBuffer = await createZipBundle(buildDir);
-        console.log(`   ✓ Bundle created (${(zipBuffer.length / 1024).toFixed(1)} KB)`);
-        console.log('');
+    // Validated before use rather than trusted from the parse: a third-party
+    // manifest is hand-written, and `"translations": "de"` would otherwise reach
+    // checkTranslations and fail as a TypeError rather than as a manifest error.
+    const declared = manifest.translations;
+    if (declared !== undefined && !isArrayOfStrings(declared)) {
+        throw new Error('Invalid manifest.json - "translations" must be an array of locale ' +
+            'codes, e.g. ["nl", "de"]. Omit the key entirely if your app ships ' +
+            'no translations.');
     }
-    catch (error) {
-        console.error(`❌ Failed to create bundle: ${error instanceof Error ? error.message : String(error)}`);
-        process.exit(1);
+    const translationsProblem = checkTranslations(declared ?? [], listBundledLocales(buildDir));
+    if (translationsProblem) {
+        throw new Error(translationsProblem);
     }
-    console.log('☁️  Uploading to Juuno...');
-    let result;
-    try {
-        result = await uploadBundle(token, zipBuffer, apiUrl);
-        console.log('   ✓ Upload complete');
+    return manifest;
+}
+/**
+ * Decide whether a deploy should be skipped because the version is already
+ * live. Returns true when the caller should return early; throws when the
+ * deploy should fail (version-already-deployed without skipIfDeployed).
+ */
+function shouldSkipDeploy(deployedVersion, manifest, skipIfDeployed) {
+    if (deployedVersion === null || deployedVersion !== manifest.version) {
+        return false;
+    }
+    if (skipIfDeployed) {
         console.log('');
+        console.log(`ℹ️  ${manifest.name}@${manifest.version} already deployed, skipping.`);
+        console.log('');
+        return true;
     }
-    catch (error) {
-        console.error(`❌ ${error instanceof Error ? error.message : String(error)}`);
-        process.exit(1);
+    throw new Error(`Version ${manifest.version} is already deployed for '${manifest.name}'\n\n   Versions are immutable. Bump the version in your manifest and try again.`);
+}
+function printVersionDelta(deployedVersion, manifest) {
+    if (deployedVersion !== null) {
+        console.log(`   Current: ${deployedVersion} → New: ${manifest.version}`);
+    }
+    else {
+        console.log('   First deploy for this app');
     }
+    console.log('');
+}
+function printDeploySuccess(result) {
     console.log('✅ Deployment successful!');
     console.log('');
     if (result.data) {
@@ -207,3 +263,41 @@ export async function deployApp(options) {
         console.log('');
     }
 }
+/**
+ * Deploys an external app to the Juuno platform.
+ */
+export async function deployApp(options) {
+    console.log('📦 Juuno CLI - Deploy');
+    console.log('');
+    try {
+        const manifest = loadAndValidateManifest(options.buildDir);
+        console.log(`   App: ${manifest.name}`);
+        console.log(`   Version: ${manifest.version}`);
+        console.log(`   ID: ${manifest.id}`);
+        console.log('');
+        const apiUrl = getApiUrl(options);
+        console.log('🔑 Authenticating...');
+        const token = await getAuthToken(options);
+        console.log('   ✓ Authenticated');
+        console.log('');
+        console.log('🔍 Checking deployed version...');
+        const deployedVersion = await fetchDeployedVersion(token, manifest.id, apiUrl);
+        if (shouldSkipDeploy(deployedVersion, manifest, options.skipIfDeployed)) {
+            return;
+        }
+        printVersionDelta(deployedVersion, manifest);
+        console.log('📁 Creating bundle...');
+        const zipBuffer = await createZipBundle(options.buildDir);
+        console.log(`   ✓ Bundle created (${(zipBuffer.length / 1024).toFixed(1)} KB)`);
+        console.log('');
+        console.log('☁️  Uploading to Juuno...');
+        const result = await uploadBundle(token, zipBuffer, apiUrl);
+        console.log('   ✓ Upload complete');
+        console.log('');
+        printDeploySuccess(result);
+    }
+    catch (error) {
+        console.error(`❌ ${getErrorMessage(error)}`);
+        process.exit(1);
+    }
+}

package/dist/cli/src/dev/index.js

@@ -42,38 +42,58 @@ async function waitForPort(port, timeoutMs = 30000) {
     return false;
 }
 /**
- * Detect if the current directory contains a Juuno external app.
+ * Lockfile lookup table. first hit wins. Adding a manager is one entry.
  */
-function detectApp(cwd) {
-    const hasViteConfig = existsSync(join(cwd, 'vite.config.ts')) ||
-        existsSync(join(cwd, 'vite.config.js'));
-    const hasPackageJson = existsSync(join(cwd, 'package.json'));
-    let hasDevScript = false;
-    let packageManager = 'npm';
-    if (hasPackageJson) {
-        try {
-            const packageJson = JSON.parse(readFileSync(join(cwd, 'package.json'), 'utf-8'));
-            hasDevScript = !!packageJson.scripts?.dev;
-        }
-        catch {
-            // Ignore parse errors.
+const PACKAGE_MANAGER_LOCKFILES = [
+    { lockfile: 'pnpm-lock.yaml', manager: 'pnpm' },
+    { lockfile: 'yarn.lock', manager: 'yarn' },
+    { lockfile: 'package-lock.json', manager: 'npm' },
+];
+function detectPackageManager(cwd) {
+    for (const { lockfile, manager } of PACKAGE_MANAGER_LOCKFILES) {
+        if (findFileUpward(cwd, lockfile)) {
+            return manager;
         }
     }
-    // Detect package manager from lockfiles (check current dir and parent dirs for monorepo support).
-    if (findFileUpward(cwd, 'pnpm-lock.yaml')) {
-        packageManager = 'pnpm';
+    return 'npm';
+}
+/**
+ * Map a detected package manager to the (command, args) pair that runs
+ * vite with the configured port. Pure.
+ */
+function buildDevCommand(pm, servePort) {
+    const args = ['vite', '--port', servePort, '--strictPort'];
+    if (pm === 'pnpm') {
+        return { command: 'pnpm', args: ['exec', ...args] };
+    }
+    if (pm === 'yarn') {
+        return { command: 'yarn', args };
+    }
+    return { command: 'npx', args };
+}
+function readDevScriptPresence(cwd) {
+    const path = join(cwd, 'package.json');
+    if (!existsSync(path)) {
+        return false;
     }
-    else if (findFileUpward(cwd, 'yarn.lock')) {
-        packageManager = 'yarn';
+    try {
+        const packageJson = JSON.parse(readFileSync(path, 'utf-8'));
+        return !!packageJson.scripts?.dev;
     }
-    else if (findFileUpward(cwd, 'package-lock.json')) {
-        packageManager = 'npm';
+    catch {
+        return false;
     }
+}
+/**
+ * Detect if the current directory contains a Juuno external app.
+ */
+function detectApp(cwd) {
     return {
-        hasViteConfig,
-        hasPackageJson,
-        hasDevScript,
-        packageManager,
+        hasViteConfig: existsSync(join(cwd, 'vite.config.ts')) ||
+            existsSync(join(cwd, 'vite.config.js')),
+        hasPackageJson: existsSync(join(cwd, 'package.json')),
+        hasDevScript: readDevScriptPresence(cwd),
+        packageManager: detectPackageManager(cwd),
     };
 }
 /**
@@ -131,21 +151,7 @@ export async function runDev(options) {
     }
     // Step 1: Start Vite dev server.
     console.log('🚀 Starting Vite dev server...\n');
-    // Build the command and args based on package manager.
-    let devCommand;
-    let devArgs;
-    if (pm === 'pnpm') {
-        devCommand = 'pnpm';
-        devArgs = ['exec', 'vite', '--port', servePort, '--strictPort'];
-    }
-    else if (pm === 'yarn') {
-        devCommand = 'yarn';
-        devArgs = ['vite', '--port', servePort, '--strictPort'];
-    }
-    else {
-        devCommand = 'npx';
-        devArgs = ['vite', '--port', servePort, '--strictPort'];
-    }
+    const { command: devCommand, args: devArgs } = buildDevCommand(pm, servePort);
     const devProcess = spawn(devCommand, devArgs, {
         cwd,
         stdio: ['ignore', 'pipe', 'pipe'],

package/dist/cli/src/info/index.js

@@ -1,32 +1,16 @@
 import { getAuthToken, getApiUrl } from '../auth/index.js';
+import { getErrorMessage } from '../utils/error.js';
+import { assertSuccessEnvelope, fetchAuthorisedJson, wrapError, } from '../utils/api.js';
 /**
  * Fetches detailed information about a specific app.
  */
 async function fetchAppInfo(token, appId, apiUrl) {
-    const infoUrl = `${apiUrl}/api/v1/developer/apps/${appId}`;
     try {
-        const response = await fetch(infoUrl, {
-            method: 'GET',
-            headers: {
-                Authorization: `Bearer ${token}`,
-                Accept: 'application/json',
-            },
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            throw new Error(`Failed to fetch app info: ${response.status} ${response.statusText}\n${errorText}`);
-        }
-        const data = (await response.json());
-        if (!data.success || !data.data) {
-            throw new Error(`Failed to fetch app info: ${data.message || 'Unknown error'}`);
-        }
-        return data.data;
+        const envelope = await fetchAuthorisedJson(`${apiUrl}/api/v1/developer/apps/${appId}`, token);
+        return assertSuccessEnvelope(envelope);
     }
     catch (error) {
-        if (error instanceof Error) {
-            throw new Error(`Failed to fetch app info: ${error.message}`);
-        }
-        throw new Error('Failed to fetch app info: Unknown error');
+        throw wrapError('Failed to fetch app info', error);
     }
 }
 /**
@@ -84,28 +68,20 @@ export async function getAppInfo(options) {
         console.error('   Usage: juuno-cli info <app-id>');
         process.exit(1);
     }
-    const apiUrl = getApiUrl(options);
-    console.log('🔑 Authenticating...');
-    let token;
     try {
-        token = await getAuthToken(options);
+        const apiUrl = getApiUrl(options);
+        console.log('🔑 Authenticating...');
+        const token = await getAuthToken(options);
         console.log('   ✓ Authenticated');
         console.log('');
-    }
-    catch (error) {
-        console.error(`❌ ${error instanceof Error ? error.message : String(error)}`);
-        process.exit(1);
-    }
-    console.log(`📡 Fetching app info for: ${options.appId}`);
-    let appInfo;
-    try {
-        appInfo = await fetchAppInfo(token, options.appId, apiUrl);
+        console.log(`📡 Fetching app info for: ${options.appId}`);
+        const appInfo = await fetchAppInfo(token, options.appId, apiUrl);
         console.log('   ✓ Info retrieved');
         console.log('');
+        displayAppInfo(appInfo);
     }
     catch (error) {
-        console.error(`❌ ${error instanceof Error ? error.message : String(error)}`);
+        console.error(`❌ ${getErrorMessage(error)}`);
         process.exit(1);
     }
-    displayAppInfo(appInfo);
 }

package/dist/cli/src/list/index.js

@@ -1,32 +1,16 @@
 import { getAuthToken, getApiUrl } from '../auth/index.js';
+import { getErrorMessage } from '../utils/error.js';
+import { assertSuccessEnvelope, fetchAuthorisedJson, wrapError, } from '../utils/api.js';
 /**
  * Fetches the list of developer apps from the API.
  */
 async function fetchAppList(token, apiUrl) {
-    const listUrl = `${apiUrl}/api/v1/developer/apps`;
     try {
-        const response = await fetch(listUrl, {
-            method: 'GET',
-            headers: {
-                Authorization: `Bearer ${token}`,
-                Accept: 'application/json',
-            },
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            throw new Error(`Failed to fetch apps: ${response.status} ${response.statusText}\n${errorText}`);
-        }
-        const data = (await response.json());
-        if (!data.success) {
-            throw new Error(`Failed to fetch apps: ${data.message || 'Unknown error'}`);
-        }
-        return data.data || [];
+        const envelope = await fetchAuthorisedJson(`${apiUrl}/api/v1/developer/apps`, token);
+        return assertSuccessEnvelope(envelope);
     }
     catch (error) {
-        if (error instanceof Error) {
-            throw new Error(`Failed to fetch apps: ${error.message}`);
-        }
-        throw new Error('Failed to fetch apps: Unknown error');
+        throw wrapError('Failed to fetch apps', error);
     }
 }
 /**
@@ -75,28 +59,20 @@ function displayAppList(apps) {
 export async function listApps(options) {
     console.log('📦 Juuno CLI - List Apps');
     console.log('');
-    const apiUrl = getApiUrl(options);
-    console.log('🔑 Authenticating...');
-    let token;
     try {
-        token = await getAuthToken(options);
+        const apiUrl = getApiUrl(options);
+        console.log('🔑 Authenticating...');
+        const token = await getAuthToken(options);
         console.log('   ✓ Authenticated');
         console.log('');
-    }
-    catch (error) {
-        console.error(`❌ ${error instanceof Error ? error.message : String(error)}`);
-        process.exit(1);
-    }
-    console.log('📡 Fetching apps...');
-    let apps;
-    try {
-        apps = await fetchAppList(token, apiUrl);
+        console.log('📡 Fetching apps...');
+        const apps = await fetchAppList(token, apiUrl);
         console.log('   ✓ Apps retrieved');
         console.log('');
+        displayAppList(apps);
     }
     catch (error) {
-        console.error(`❌ ${error instanceof Error ? error.message : String(error)}`);
+        console.error(`❌ ${getErrorMessage(error)}`);
         process.exit(1);
     }
-    displayAppList(apps);
 }