@norrix/cli 0.0.6 → 0.0.8

package/dist/lib/commands.js

@@ -8,6 +8,7 @@ import { fileURLToPath } from 'url';
 import archiver from 'archiver';
 // import FormData from 'form-data';
 import { configureAmplify } from './amplify-config.js';
+import { computeFingerprint, writeFingerprintFile } from './fingerprinting.js';
 import { signIn as amplifySignIn, signOut as amplifySignOut, getCurrentUser, fetchAuthSession, } from 'aws-amplify/auth';
 import crypto from 'crypto';
 import { Amplify } from 'aws-amplify';
@@ -112,6 +113,11 @@ function getS3BucketRegionFromAmplify() {
     }
     return { bucket, region };
 }
+function logVerbose(message, verbose) {
+    if (verbose) {
+        console.log(message);
+    }
+}
 async function uploadToS3Sdk(key, data) {
     const { bucket, region } = getS3BucketRegionFromAmplify();
     let credentials = undefined;
@@ -133,6 +139,198 @@ async function uploadToS3Sdk(key, data) {
     const client = new S3Client({ region, credentials });
     await client.send(new PutObjectCommand({ Bucket: bucket, Key: key, Body: data }));
 }
+export async function printFingerprint(cliPlatformArg, appId, verbose = false) {
+    try {
+        const projectRoot = process.cwd();
+        const platform = (cliPlatformArg || '').toLowerCase() || undefined;
+        const snapshot = computeFingerprint({
+            projectRoot,
+            platform,
+            appId,
+        });
+        writeFingerprintFile(projectRoot, snapshot);
+        console.log('Norrix fingerprint snapshot:');
+        console.log(JSON.stringify(snapshot, null, 2));
+    }
+    catch (error) {
+        ora().fail(`Failed to compute fingerprint: ${error?.message || error}`);
+        if (verbose) {
+            console.error('--- Verbose error details (fingerprint) ---');
+            console.error(error);
+            if (error?.stack) {
+                console.error(error.stack);
+            }
+        }
+    }
+}
+async function fetchBuildFingerprint(buildId, verbose = false) {
+    try {
+        const spinner = ora(`Fetching fingerprint for build ${buildId}...`).start();
+        const response = await axios.get(`${API_URL}/build/${buildId}`, {
+            headers: await getAuthHeaders(),
+        });
+        spinner.stop();
+        const build = response.data;
+        if (!build?.fingerprintHash || !build?.fingerprintNativeJson) {
+            console.log(`Build ${buildId} does not have fingerprint data recorded (fingerprintHash/fingerprintNativeJson missing).`);
+            return undefined;
+        }
+        let nativeJson = {};
+        try {
+            nativeJson = JSON.parse(build.fingerprintNativeJson || '{}');
+        }
+        catch {
+            nativeJson = {};
+        }
+        return {
+            hash: build.fingerprintHash,
+            nativePlugins: nativeJson.nativePlugins || {},
+            appResourcesHash: nativeJson.appResourcesHash ?? null,
+            nativeSourcesHash: nativeJson.nativeSourcesHash ?? null,
+            platform: build.platform ?? null,
+        };
+    }
+    catch (error) {
+        ora().fail(`Failed to fetch fingerprint for build ${buildId}: ${error?.message || error}`);
+        if (verbose) {
+            console.error('--- Verbose error details (fingerprint-compare/fetch) ---');
+            console.error(error);
+            if (error?.response) {
+                console.error('Axios response status:', error.response.status);
+                console.error('Axios response data:', error.response.data);
+            }
+            if (error?.stack) {
+                console.error(error.stack);
+            }
+        }
+        return undefined;
+    }
+}
+function diffPluginMaps(fromPlugins, toPlugins) {
+    const added = [];
+    const removed = [];
+    const changed = [];
+    const allNames = new Set([
+        ...Object.keys(fromPlugins),
+        ...Object.keys(toPlugins),
+    ]);
+    for (const name of allNames) {
+        const fromV = fromPlugins[name];
+        const toV = toPlugins[name];
+        if (fromV && !toV) {
+            removed.push({ name, version: fromV });
+        }
+        else if (!fromV && toV) {
+            added.push({ name, version: toV });
+        }
+        else if (fromV && toV && fromV !== toV) {
+            changed.push({ name, from: fromV, to: toV });
+        }
+    }
+    return { added, removed, changed };
+}
+export async function compareFingerprint(fromBuildId, toArg, verbose = false) {
+    try {
+        if (!fromBuildId) {
+            throw new Error('Missing required --from <build-id> argument');
+        }
+        const fromFp = await fetchBuildFingerprint(fromBuildId, verbose);
+        if (!fromFp) {
+            ora().fail(`Build ${fromBuildId} does not have fingerprint data; cannot compare.`);
+            return;
+        }
+        const toIsLocal = !toArg || toArg === 'local';
+        let toLabel;
+        let toFp;
+        if (toIsLocal) {
+            const projectRoot = process.cwd();
+            const platform = fromFp.platform || undefined;
+            const localSnapshot = computeFingerprint({
+                projectRoot,
+                platform: platform || undefined,
+            });
+            toFp = {
+                hash: localSnapshot.hash,
+                nativePlugins: localSnapshot.nativePlugins,
+                appResourcesHash: localSnapshot.appResourcesHash ?? null,
+                nativeSourcesHash: localSnapshot.nativeSourcesHash ?? null,
+                platform: platform || undefined,
+            };
+            toLabel = 'local project';
+        }
+        else {
+            toFp = await fetchBuildFingerprint(toArg, verbose);
+            if (!toFp) {
+                ora().fail(`Build ${toArg} does not have fingerprint data; cannot compare.`);
+                return;
+            }
+            toLabel = `build ${toArg}`;
+        }
+        console.log('\nFingerprint comparison');
+        console.log('----------------------');
+        console.log(`From: build ${fromBuildId}`);
+        console.log(`  Platform: ${fromFp.platform || 'unknown'}`);
+        console.log(`  Hash:     ${fromFp.hash}`);
+        console.log(`To:   ${toLabel}`);
+        console.log(`  Platform: ${toFp.platform || fromFp.platform || 'unknown'}`);
+        console.log(`  Hash:     ${toFp.hash}`);
+        const hashesMatch = fromFp.hash === toFp.hash;
+        console.log('\nSummary');
+        if (hashesMatch) {
+            console.log('- Native fingerprints are identical (hash values match). OTA compatibility is expected.');
+        }
+        else {
+            console.log('- Native fingerprints differ (hash values do not match). OTA between these may require a new store binary.');
+        }
+        const pluginDiff = diffPluginMaps(fromFp.nativePlugins || {}, toFp.nativePlugins || {});
+        console.log('\nNativeScript plugin differences');
+        if (pluginDiff.added.length === 0 &&
+            pluginDiff.removed.length === 0 &&
+            pluginDiff.changed.length === 0) {
+            console.log('- No plugin differences detected');
+        }
+        else {
+            if (pluginDiff.added.length) {
+                console.log('- Added plugins:');
+                for (const p of pluginDiff.added) {
+                    console.log(`    + ${p.name}@${p.version}`);
+                }
+            }
+            if (pluginDiff.removed.length) {
+                console.log('- Removed plugins:');
+                for (const p of pluginDiff.removed) {
+                    console.log(`    - ${p.name}@${p.version}`);
+                }
+            }
+            if (pluginDiff.changed.length) {
+                console.log('- Changed plugins:');
+                for (const p of pluginDiff.changed) {
+                    console.log(`    ~ ${p.name}: ${p.from} -> ${p.to}`);
+                }
+            }
+        }
+        console.log('\nApp_Resources hash');
+        console.log(`- From: ${fromFp.appResourcesHash || 'none'}`);
+        console.log(`- To:   ${toFp.appResourcesHash || 'none'}`);
+        console.log('\niOS NativeSource hash');
+        console.log(`- From: ${fromFp.nativeSourcesHash || 'none'}`);
+        console.log(`- To:   ${toFp.nativeSourcesHash || 'none'}`);
+    }
+    catch (error) {
+        ora().fail(`Failed to compare fingerprints: ${error?.message || error}`);
+        if (verbose) {
+            console.error('--- Verbose error details (fingerprint-compare) ---');
+            console.error(error);
+            if (error?.response) {
+                console.error('Axios response status:', error.response.status);
+                console.error('Axios response data:', error.response.data);
+            }
+            if (error?.stack) {
+                console.error(error.stack);
+            }
+        }
+    }
+}
 /**
  * Get the current NativeScript project's name from package.json
  */
@@ -174,6 +372,99 @@ function getNativeScriptAppPath() {
     }
     return undefined;
 }
+/**
+ * Parse NativeScript app id from nativescript.config.(ts|js).
+ * Looks for top-level `id`, then platform-specific `ios.id` / `android.id`.
+ */
+function getNativeScriptAppId(platform) {
+    const normalizedPlatform = (platform || '').toLowerCase();
+    const candidates = ['nativescript.config.ts', 'nativescript.config.js'];
+    try {
+        for (const file of candidates) {
+            const full = path.join(process.cwd(), file);
+            if (!fs.existsSync(full))
+                continue;
+            const content = fs.readFileSync(full, 'utf8');
+            // Prefer platform-specific id if platform is known
+            if (normalizedPlatform === 'ios' || normalizedPlatform === 'visionos') {
+                const m = content.match(/ios\s*:\s*{[^}]*id\s*:\s*['"`]([^'"`]+)['"`]/s);
+                if (m && m[1])
+                    return m[1].trim();
+            }
+            else if (normalizedPlatform === 'android') {
+                const m = content.match(/android\s*:\s*{[^}]*id\s*:\s*['"`]([^'"`]+)['"`]/s);
+                if (m && m[1])
+                    return m[1].trim();
+            }
+            // Fallback to top-level id
+            const topLevel = content.match(/id\s*:\s*['"`]([^'"`]+)['"`]/);
+            if (topLevel && topLevel[1])
+                return topLevel[1].trim();
+        }
+    }
+    catch (_) {
+        // ignore parse errors and fall back to manual input
+    }
+    return undefined;
+}
+function getNativeScriptAppResourcesPath() {
+    try {
+        const candidates = ['nativescript.config.ts', 'nativescript.config.js'];
+        for (const file of candidates) {
+            const full = path.join(process.cwd(), file);
+            if (!fs.existsSync(full))
+                continue;
+            const content = fs.readFileSync(full, 'utf8');
+            const match = content.match(/appResourcesPath\s*:\s*['"`]([^'"`]+)['"`]/);
+            if (match && match[1]) {
+                return match[1].trim();
+            }
+        }
+    }
+    catch (_) {
+        // ignore parse errors and fall back
+    }
+    return undefined;
+}
+function getAppleVersionFromInfoPlist(platform) {
+    const appResourcesPath = getNativeScriptAppResourcesPath();
+    if (!appResourcesPath)
+        return {};
+    const platformDir = platform.toLowerCase() === 'visionos' ? 'visionOS' : 'iOS';
+    const plistPath = path.join(process.cwd(), appResourcesPath, platformDir, 'Info.plist');
+    if (!fs.existsSync(plistPath))
+        return {};
+    try {
+        const xml = fs.readFileSync(plistPath, 'utf8');
+        const shortVersionMatch = xml.match(/<key>CFBundleShortVersionString<\/key>\s*<string>([^<]+)<\/string>/);
+        const bundleVersionMatch = xml.match(/<key>CFBundleVersion<\/key>\s*<string>([^<]+)<\/string>/);
+        const version = shortVersionMatch?.[1]?.trim();
+        const buildNumber = bundleVersionMatch?.[1]?.trim();
+        return { version, buildNumber };
+    }
+    catch (_) {
+        return {};
+    }
+}
+function getAndroidVersionFromAppGradle() {
+    const appResourcesPath = getNativeScriptAppResourcesPath();
+    if (!appResourcesPath)
+        return {};
+    const gradlePath = path.join(process.cwd(), appResourcesPath, 'Android', 'app.gradle');
+    if (!fs.existsSync(gradlePath))
+        return {};
+    try {
+        const content = fs.readFileSync(gradlePath, 'utf8');
+        const versionNameMatch = content.match(/versionName\s+"([^"]+)"/);
+        const versionCodeMatch = content.match(/versionCode\s+(\d+)/);
+        const version = versionNameMatch?.[1]?.trim();
+        const buildNumber = versionCodeMatch?.[1]?.trim();
+        return { version, buildNumber };
+    }
+    catch (_) {
+        return {};
+    }
+}
 /**
  * Creates a zip file of the current directory (NativeScript project)
  */
@@ -222,9 +513,7 @@ async function zipProject(projectName, isUpdate = false) {
         }
         else {
             console.warn('Warning: app directory not found in the project root');
-            const checked = [nsAppDir, srcDir, appDir]
-                .filter(Boolean)
-                .join(', ');
+            const checked = [nsAppDir, srcDir, appDir].filter(Boolean).join(', ');
             console.warn(`Checked locations: ${checked}`);
             console.log('Creating an empty app directory in the zip');
         }
@@ -246,20 +535,27 @@ async function zipProject(projectName, isUpdate = false) {
  * Build command implementation
  * Uploads project to S3 and triggers build via the Next.js API gateway -> WarpBuild
  */
-export async function build() {
+export async function build(cliPlatformArg, verbose = false) {
     try {
         const spinner = ora('Preparing app for building...').start();
         // 1. Get project info
         const projectName = await getProjectName();
-        // 2. Ask for platform
+        // 2. Determine platform (CLI arg preferred, otherwise prompt)
+        let platform = (cliPlatformArg || '').toLowerCase();
+        const validPlatforms = ['android', 'ios', 'visionos'];
         spinner.stop();
-        const { platform, configuration } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'platform',
-                message: 'Select target platform:',
-                choices: ['android', 'ios'],
-            },
+        if (!validPlatforms.includes(platform)) {
+            const { chosenPlatform } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'chosenPlatform',
+                    message: 'Select target platform:',
+                    choices: validPlatforms,
+                },
+            ]);
+            platform = chosenPlatform;
+        }
+        const { configuration } = await inquirer.prompt([
             {
                 type: 'list',
                 name: 'configuration',
@@ -268,32 +564,52 @@ export async function build() {
                 default: 'debug',
             },
         ]);
+        const appleVersionInfo = platform === 'ios' || platform === 'visionos'
+            ? getAppleVersionFromInfoPlist(platform)
+            : {};
+        const inferredIosOrVisionVersion = appleVersionInfo.version;
+        const androidVersionInfo = platform === 'android' ? getAndroidVersionFromAppGradle() : {};
+        const inferredAndroidVersion = androidVersionInfo.version;
+        const inferredVersion = inferredIosOrVisionVersion || inferredAndroidVersion || '';
+        if (inferredVersion) {
+            logVerbose(`Auto-detected app version from project files: ${inferredVersion}`, verbose);
+        }
         const { version } = await inquirer.prompt([
             {
                 type: 'input',
                 name: 'version',
-                message: 'App version (optional):',
-                default: '',
+                message: inferredVersion
+                    ? `App version (${inferredVersion}, enter to accept):`
+                    : 'App version:',
+                default: inferredVersion,
                 validate: (input) => {
                     const val = String(input).trim();
-                    if (val === '')
-                        return true; // optional
+                    if (val === '') {
+                        return 'Version is required';
+                    }
                     // Strict SemVer: MAJOR.MINOR.PATCH with optional -prerelease and +build metadata
                     const semverRe = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/;
                     return semverRe.test(val)
                         ? true
-                        : 'Enter a valid semver (e.g., 2.0.0 or 2.0.0-beta.1) or leave blank';
+                        : 'Enter a valid semver (e.g., 2.0.0 or 2.0.0-beta.1)';
                 },
             },
         ]);
         let buildNumber;
         if (platform === 'android') {
+            const inferredAndroid = androidVersionInfo;
+            const inferredVersionCode = inferredAndroid.buildNumber;
+            if (inferredVersionCode) {
+                logVerbose(`Auto-detected Android versionCode from app.gradle: ${inferredVersionCode}`, verbose);
+            }
             const { versionCode } = await inquirer.prompt([
                 {
                     type: 'input',
                     name: 'versionCode',
-                    message: 'App build number, aka versionCode (optional - will auto increment when blank):',
-                    default: '',
+                    message: inferredVersionCode
+                        ? `App build number, aka versionCode (${inferredVersionCode} - enter to auto increment):`
+                        : 'App build number, aka versionCode (enter to auto increment):',
+                    default: inferredVersionCode || '',
                     validate: (input) => {
                         const val = String(input).trim();
                         if (val === '')
@@ -434,6 +750,13 @@ export async function build() {
             }
             spinner.start('Creating project archive...');
         }
+        // Compute a native-layer fingerprint before archiving
+        const projectRoot = process.cwd();
+        const fingerprint = computeFingerprint({
+            projectRoot,
+            platform,
+        });
+        writeFingerprintFile(projectRoot, fingerprint);
         spinner.start('Creating project archive...');
         // 3. Zip the project
         const zipPath = await zipProject(projectName, false);
@@ -460,6 +783,7 @@ export async function build() {
             version: version || '',
             buildNumber: buildNumber || '',
             configuration,
+            fingerprint,
             // Provide the relative key (without public/) – the workflow prepends public/
             s3Key: s3KeyRel,
             // Only include raw credentials if not encrypted
@@ -483,14 +807,25 @@ export async function build() {
         console.log(`   You can check the status with: norrix build-status ${buildId}`);
     }
     catch (error) {
-        ora().fail(`Build failed: ${error.message}`);
+        ora().fail(`Build failed: ${error?.message || error}`);
+        if (verbose) {
+            console.error('--- Verbose error details (build) ---');
+            console.error(error);
+            if (error?.response) {
+                console.error('Axios response status:', error.response.status);
+                console.error('Axios response data:', error.response.data);
+            }
+            if (error?.stack) {
+                console.error(error.stack);
+            }
+        }
     }
 }
 /**
  * Submit command implementation
  * Submits the built app to app stores via the Next.js API gateway
  */
-export async function submit() {
+export async function submit(cliPlatformArg, verbose = false) {
     try {
         const spinner = ora('Preparing app for submission...').start();
         // 1. Get available builds to show in prompt
@@ -505,11 +840,13 @@ export async function submit() {
                 // Filter for successful builds
                 availableBuilds = buildsResponse.data.builds
                     .filter((build) => build.status === 'success')
-                    .map((build) => ({
-                    name: `${build.projectName} (${build.platform} - ${build.id})`,
-                    value: build.id,
-                    platform: build.platform,
-                }));
+                    .map((build) => {
+                    return {
+                        name: `${build.projectName} (${build.platform} - ${build.version} (${build.buildNumber}) - ${build.id})`,
+                        value: build.id,
+                        platform: build.platform,
+                    };
+                });
             }
         }
         catch (error) {
@@ -541,20 +878,24 @@ export async function submit() {
             ]);
             buildId = buildIdAnswer.buildId;
         }
-        // Get the platform for the selected build
-        const selectedBuild = availableBuilds.find((build) => build.value === buildId);
-        const defaultPlatform = selectedBuild ? selectedBuild.platform : null;
-        let platform;
-        if (defaultPlatform) {
-            platform = defaultPlatform;
+        // Determine platform, preferring CLI arg, then build metadata, then prompt
+        let platform = (cliPlatformArg || '').toLowerCase();
+        const validPlatforms = ['android', 'ios', 'visionos'];
+        // Fallback to platform from selected build if CLI arg missing/invalid
+        if (!validPlatforms.includes(platform)) {
+            const selectedBuild = availableBuilds.find((build) => build.value === buildId);
+            if (selectedBuild && validPlatforms.includes(selectedBuild.platform)) {
+                platform = selectedBuild.platform;
+            }
         }
-        else {
+        // If still unknown, prompt the user
+        if (!validPlatforms.includes(platform)) {
             const platformAnswer = await inquirer.prompt([
                 {
                     type: 'list',
                     name: 'platform',
                     message: 'Select target platform:',
-                    choices: ['android', 'ios'],
+                    choices: validPlatforms,
                 },
             ]);
             platform = platformAnswer.platform;
@@ -656,16 +997,51 @@ export async function submit() {
         console.log(`   You can check the status with: norrix submit-status ${submitId}`);
     }
     catch (error) {
-        ora().fail(`Submission failed: ${error.message}`);
+        ora().fail(`Submission failed: ${error?.message || error}`);
+        if (verbose) {
+            console.error('--- Verbose error details (submit) ---');
+            console.error(error);
+            if (error?.response) {
+                console.error('Axios response status:', error.response.status);
+                console.error('Axios response data:', error.response.data);
+            }
+            if (error?.stack) {
+                console.error(error.stack);
+            }
+        }
     }
 }
 /**
  * Update command implementation
  * Publishes over-the-air updates to deployed apps via the Next.js API gateway
  */
-export async function update() {
+export async function update(cliPlatformArg, verbose = false) {
     try {
         const spinner = ora('Preparing over-the-air update...').start();
+        // Normalize and/or ask for platform first (CLI arg takes precedence if valid)
+        let platform = (cliPlatformArg || '').toLowerCase();
+        const validPlatforms = ['android', 'ios', 'visionos'];
+        if (!validPlatforms.includes(platform)) {
+            spinner.stop();
+            const { chosenPlatform } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'chosenPlatform',
+                    message: 'Which platform?',
+                    choices: validPlatforms,
+                },
+            ]);
+            platform = chosenPlatform;
+            spinner.start('Preparing over-the-air update...');
+        }
+        // Attempt to infer app ID from NativeScript config based on platform
+        let inferredAppId;
+        try {
+            inferredAppId = getNativeScriptAppId(platform);
+        }
+        catch (_) {
+            // ignore, will fall back to prompt without default
+        }
         // Ask for app ID and other details
         spinner.stop();
         const { appId, version, notes } = await inquirer.prompt([
@@ -673,6 +1049,7 @@ export async function update() {
                 type: 'input',
                 name: 'appId',
                 message: 'Enter the App ID to update:',
+                default: inferredAppId || '',
                 validate: (input) => input.length > 0 || 'App ID is required',
             },
             {
@@ -701,6 +1078,15 @@ export async function update() {
             spinner.warn('Warning: app directory not found in the project. The update may be incomplete.');
             spinner.warn('Expected app at either:\n- ' + appDir + '\n- ' + srcAppDir);
         }
+        // Compute fingerprint for the current app state so the backend can
+        // compare it with the binary fingerprint and decide if OTA is allowed.
+        const projectRoot = process.cwd();
+        const fingerprint = computeFingerprint({
+            projectRoot,
+            platform,
+            appId,
+        });
+        writeFingerprintFile(projectRoot, fingerprint);
         spinner.start('Packaging JavaScript bundle for over-the-air update...');
         // Create the update bundle - pass true to include node_modules for updates
         const projectName = await getProjectName();
@@ -714,8 +1100,10 @@ export async function update() {
         spinner.text = 'Upload complete. Starting update...';
         const response = await axios.post(`${API_URL}/update`, {
             appId,
+            platform,
             version,
             releaseNotes: notes,
+            fingerprint,
             // Provide the relative key (without public/). Consumers will prepend public/
             s3Key: s3KeyRel,
         }, {
@@ -733,14 +1121,25 @@ export async function update() {
         console.log(`   You can check the status with: norrix update-status ${updateId}`);
     }
     catch (error) {
-        ora().fail(`Update failed: ${error.message}`);
+        ora().fail(`Update failed: ${error?.message || error}`);
+        if (verbose) {
+            console.error('--- Verbose error details (update) ---');
+            console.error(error);
+            if (error?.response) {
+                console.error('Axios response status:', error.response.status);
+                console.error('Axios response data:', error.response.data);
+            }
+            if (error?.stack) {
+                console.error(error.stack);
+            }
+        }
     }
 }
 /**
  * Build Status command implementation
  * Checks the status of a build via the Next.js API gateway
  */
-export async function buildStatus(buildId) {
+export async function buildStatus(buildId, verbose = false) {
     try {
         const spinner = ora(`Checking status of build ${buildId}...`).start();
         const response = await axios.get(`${API_URL}/build/${buildId}`, {
@@ -759,14 +1158,25 @@ export async function buildStatus(buildId) {
         }
     }
     catch (error) {
-        ora().fail(`Failed to check build status: ${error.message}`);
+        ora().fail(`Failed to check build status: ${error?.message || error}`);
+        if (verbose) {
+            console.error('--- Verbose error details (build-status) ---');
+            console.error(error);
+            if (error?.response) {
+                console.error('Axios response status:', error.response.status);
+                console.error('Axios response data:', error.response.data);
+            }
+            if (error?.stack) {
+                console.error(error.stack);
+            }
+        }
     }
 }
 /**
  * Submit Status command implementation
  * Checks the status of a submission via the Next.js API gateway
  */
-export async function submitStatus(submitId) {
+export async function submitStatus(submitId, verbose = false) {
     try {
         const spinner = ora(`Checking status of submission ${submitId}...`).start();
         const response = await axios.get(`${API_URL}/submit/${submitId}`, {
@@ -781,14 +1191,25 @@ export async function submitStatus(submitId) {
         console.log(`Message: ${response.data.message}`);
     }
     catch (error) {
-        ora().fail(`Failed to check submission status: ${error.message}`);
+        ora().fail(`Failed to check submission status: ${error?.message || error}`);
+        if (verbose) {
+            console.error('--- Verbose error details (submit-status) ---');
+            console.error(error);
+            if (error?.response) {
+                console.error('Axios response status:', error.response.status);
+                console.error('Axios response data:', error.response.data);
+            }
+            if (error?.stack) {
+                console.error(error.stack);
+            }
+        }
     }
 }
 /**
  * Update Status command implementation
  * Checks the status of an update via the Next.js API gateway
  */
-export async function updateStatus(updateId) {
+export async function updateStatus(updateId, verbose = false) {
     try {
         const spinner = ora(`Checking status of update ${updateId}...`).start();
         const response = await axios.get(`${API_URL}/update/${updateId}`, {
@@ -803,13 +1224,24 @@ export async function updateStatus(updateId) {
         console.log(`Message: ${response.data.message}`);
     }
     catch (error) {
-        ora().fail(`Failed to check update status: ${error.message}`);
+        ora().fail(`Failed to check update status: ${error?.message || error}`);
+        if (verbose) {
+            console.error('--- Verbose error details (update-status) ---');
+            console.error(error);
+            if (error?.response) {
+                console.error('Axios response status:', error.response.status);
+                console.error('Axios response data:', error.response.data);
+            }
+            if (error?.stack) {
+                console.error(error.stack);
+            }
+        }
     }
 }
 /**
  * Sign-In command implementation (email / password via Cognito)
  */
-export async function signIn() {
+export async function signIn(verbose = false) {
     try {
         const answers = await inquirer.prompt([
             {
@@ -839,26 +1271,48 @@ export async function signIn() {
         spinner.succeed(`Signed in as ${answers.email}`);
     }
     catch (error) {
-        ora().fail(`Sign-in failed: ${error.message}`);
+        ora().fail(`Sign-in failed: ${error?.message || error}`);
+        if (verbose) {
+            console.error('--- Verbose error details (sign-in) ---');
+            console.error(error);
+            if (error?.response) {
+                console.error('Axios response status:', error.response.status);
+                console.error('Axios response data:', error.response.data);
+            }
+            if (error?.stack) {
+                console.error(error.stack);
+            }
+        }
     }
 }
 /**
  * Sign-Out command implementation
  */
-export async function signOut() {
+export async function signOut(verbose = false) {
     try {
         const spinner = ora('Signing out...').start();
         await amplifySignOut();
         spinner.succeed('Signed out successfully');
     }
     catch (error) {
-        ora().fail(`Sign-out failed: ${error.message}`);
+        ora().fail(`Sign-out failed: ${error?.message || error}`);
+        if (verbose) {
+            console.error('--- Verbose error details (sign-out) ---');
+            console.error(error);
+            if (error?.response) {
+                console.error('Axios response status:', error.response.status);
+                console.error('Axios response data:', error.response.data);
+            }
+            if (error?.stack) {
+                console.error(error.stack);
+            }
+        }
     }
 }
 /**
  * Upload a file to S3 via Amplify Storage
  */
-export async function uploadFile(filePath, options) {
+export async function uploadFile(filePath, options, verbose = false) {
     try {
         const resolvedPath = path.resolve(process.cwd(), filePath);
         if (!fs.existsSync(resolvedPath)) {
@@ -871,13 +1325,24 @@ export async function uploadFile(filePath, options) {
         spinner.succeed(`Uploaded ${key} successfully`);
     }
     catch (error) {
-        ora().fail(`Upload failed: ${error.message}`);
+        ora().fail(`Upload failed: ${error?.message || error}`);
+        if (verbose) {
+            console.error('--- Verbose error details (upload) ---');
+            console.error(error);
+            if (error?.response) {
+                console.error('Axios response status:', error.response.status);
+                console.error('Axios response data:', error.response.data);
+            }
+            if (error?.stack) {
+                console.error(error.stack);
+            }
+        }
     }
 }
 /**
  * Current User command implementation
  */
-export async function currentUser() {
+export async function currentUser(verbose = false) {
     try {
         const spinner = ora('Fetching current user...').start();
         let user;
@@ -911,7 +1376,76 @@ export async function currentUser() {
             console.log('⚠️  No user is currently signed in.');
             return;
         }
-        ora().fail(`Failed to fetch current user: ${error.message}`);
+        ora().fail(`Failed to fetch current user: ${error?.message || error}`);
+        if (verbose) {
+            console.error('--- Verbose error details (current-user) ---');
+            console.error(error);
+            if (error?.response) {
+                console.error('Axios response status:', error.response.status);
+                console.error('Axios response data:', error.response.data);
+            }
+            if (error?.stack) {
+                console.error(error.stack);
+            }
+        }
+    }
+}
+/**
+ * Open billing checkout for the current organization
+ */
+export async function billingCheckout(priceId, verbose = false) {
+    try {
+        if (!priceId) {
+            const a = await inquirer.prompt([
+                { type: 'input', name: 'priceId', message: 'Stripe Price ID:' },
+            ]);
+            priceId = a.priceId;
+        }
+        const spinner = ora('Creating checkout session...').start();
+        const res = await axios.post(`${API_URL}/billing/checkout`, { priceId }, { headers: await getAuthHeaders() });
+        spinner.succeed('Checkout session created');
+        console.log('Open this URL in your browser to complete purchase:');
+        console.log(res.data.url);
+    }
+    catch (error) {
+        ora().fail(`Checkout failed: ${error?.message || error}`);
+        if (verbose) {
+            console.error('--- Verbose error details (billing-checkout) ---');
+            console.error(error);
+            if (error?.response) {
+                console.error('Axios response status:', error.response.status);
+                console.error('Axios response data:', error.response.data);
+            }
+            if (error?.stack) {
+                console.error(error.stack);
+            }
+        }
+    }
+}
+/**
+ * Open Stripe billing portal for the current organization
+ */
+export async function billingPortal(verbose = false) {
+    try {
+        const spinner = ora('Creating billing portal session...').start();
+        const res = await axios.post(`${API_URL}/billing/portal`, {}, { headers: await getAuthHeaders() });
+        spinner.succeed('Portal session created');
+        console.log('Open this URL in your browser to manage billing:');
+        console.log(res.data.url);
+    }
+    catch (error) {
+        ora().fail(`Portal failed: ${error?.message || error}`);
+        if (verbose) {
+            console.error('--- Verbose error details (billing-portal) ---');
+            console.error(error);
+            if (error?.response) {
+                console.error('Axios response status:', error.response.status);
+                console.error('Axios response data:', error.response.data);
+            }
+            if (error?.stack) {
+                console.error(error.stack);
+            }
+        }
     }
 }
 //# sourceMappingURL=commands.js.map