@norrix/cli 0.0.24 → 0.0.25

package/dist/lib/commands.js

@@ -9,6 +9,8 @@ import archiver from 'archiver';
 // import FormData from 'form-data';
 import { configureAmplify, loadCliEnvFiles } from './amplify-config.js';
 import { computeFingerprint, writeRuntimeFingerprintFile } from './fingerprinting.js';
+import { loadNorrixConfig, hasNorrixConfig, saveNorrixConfig } from './config.js';
+import { detectWorkspaceContext, getNxProjectDependencies, getWorkspaceDependenciesFallback, createWorkspaceManifest, logWorkspaceContext, isAtWorkspaceRoot, discoverNativeScriptApps, getWorkspaceContextForApp, } from './workspace.js';
 import { signIn as amplifySignIn, signOut as amplifySignOut, getCurrentUser, fetchAuthSession, } from 'aws-amplify/auth';
 import crypto from 'crypto';
 import { Amplify } from 'aws-amplify';
@@ -635,20 +637,106 @@ function getAndroidVersionFromAppGradle() {
     }
 }
 /**
- * Creates a zip file of the current directory (NativeScript project)
+ * Resolve workspace context for a command.
+ *
+ * When running from workspace root:
+ * - If --project is provided, use that project
+ * - Otherwise, discover NativeScript apps and prompt for selection
+ *
+ * When running from within an app directory:
+ * - Use the current directory's context
+ *
+ * @param projectArg - Optional project name from --project flag
+ * @param spinner - Optional spinner to stop before prompting
+ */
+async function resolveWorkspaceContext(projectArg, spinner) {
+    const originalCwd = process.cwd();
+    // If we're at workspace root (has nx.json but no nativescript.config)
+    if (isAtWorkspaceRoot()) {
+        // If --project was provided, use it
+        if (projectArg) {
+            const ctx = getWorkspaceContextForApp(projectArg);
+            if (!ctx) {
+                const apps = discoverNativeScriptApps();
+                const appNames = apps.map((a) => a.name).join(', ');
+                throw new Error(`Project '${projectArg}' not found in workspace. Available NativeScript apps: ${appNames || 'none'}`);
+            }
+            // Change to the app directory for subsequent operations
+            process.chdir(ctx.appRoot);
+            return { workspaceContext: ctx, originalCwd };
+        }
+        // Discover NativeScript apps and prompt for selection
+        const apps = discoverNativeScriptApps();
+        if (apps.length === 0) {
+            throw new Error('No NativeScript apps found in this workspace. ' +
+                'Run this command from within a NativeScript app directory, or ensure your apps have nativescript.config.ts files.');
+        }
+        if (apps.length === 1) {
+            // Only one app, use it automatically
+            if (spinner)
+                spinner.stop();
+            console.log(`Found NativeScript app: ${apps[0].name} (${apps[0].path})`);
+            const ctx = getWorkspaceContextForApp(apps[0].name);
+            if (ctx) {
+                process.chdir(ctx.appRoot);
+                return { workspaceContext: ctx, originalCwd };
+            }
+        }
+        // Multiple apps - stop spinner before prompting
+        if (spinner)
+            spinner.stop();
+        // Multiple apps - prompt for selection
+        const { selectedApp } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'selectedApp',
+                message: 'Select a NativeScript app:',
+                choices: apps.map((app) => ({
+                    name: `${app.name} (${app.path})`,
+                    value: app.name,
+                })),
+                pageSize: 15, // Show more items to avoid scroll issues
+                loop: false, // Don't loop back to start when at end
+            },
+        ]);
+        const ctx = getWorkspaceContextForApp(selectedApp);
+        if (!ctx) {
+            throw new Error(`Failed to get context for selected app: ${selectedApp}`);
+        }
+        process.chdir(ctx.appRoot);
+        return { workspaceContext: ctx, originalCwd };
+    }
+    // Not at workspace root - use current directory
+    const ctx = detectWorkspaceContext();
+    return { workspaceContext: ctx, originalCwd };
+}
+/**
+ * Creates a zip file of the current directory (NativeScript project).
+ * For Nx workspaces, this includes the app, dependent libs, and workspace config files.
+ * For standalone projects, this zips the current directory.
  */
-async function zipProject(projectName, isUpdate = false) {
+async function zipProject(projectName, isUpdate = false, verbose = false) {
+    const workspaceCtx = detectWorkspaceContext();
+    if (workspaceCtx.type === 'nx') {
+        return zipWorkspaceProject(projectName, workspaceCtx, isUpdate, verbose);
+    }
+    else {
+        return zipStandaloneProject(projectName, workspaceCtx, isUpdate);
+    }
+}
+/**
+ * Zip a standalone NativeScript project (original behavior)
+ */
+async function zipStandaloneProject(projectName, workspaceCtx, isUpdate = false) {
     return new Promise((resolve, reject) => {
         const outputPath = path.join(process.cwd(), `${projectName}.zip`);
         const output = fs.createWriteStream(outputPath);
         const archive = archiver('zip', {
-            zlib: { level: 9 }, // Compression level
+            zlib: { level: 9 },
         });
-        // Listen for all archive data to be written
         output.on('close', () => {
-            resolve(outputPath);
+            resolve({ zipPath: outputPath, workspaceContext: workspaceCtx });
         });
-        // Listen for warnings and errors
         archive.on('warning', (err) => {
             if (err.code === 'ENOENT') {
                 console.warn('Archive warning:', err);
@@ -660,9 +748,8 @@ async function zipProject(projectName, isUpdate = false) {
         archive.on('error', (err) => {
             reject(err);
         });
-        // Pipe archive data to the file
         archive.pipe(output);
-        // Determine the primary app directory (prefer appPath from NativeScript config)
+        // Determine the primary app directory
         const nsAppPath = getNativeScriptAppPath();
         const nsAppDir = nsAppPath
             ? path.join(process.cwd(), nsAppPath)
@@ -682,18 +769,12 @@ 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(', ');
-            console.warn(`Checked locations: ${checked}`);
-            console.log('Creating an empty app directory in the zip');
         }
-        // For both builds/updates, include App_Resources and exclude node_modules.
-        // For OTA updates specifically, we also exclude the runtime fingerprint
-        // file, since it reflects the native store binary, not the OTA payload.
         const ignorePatterns = [
-            'node_modules/**', // Always exclude node_modules
-            '*.zip', // Exclude existing zip files
-            'platforms/**', // Exclude platform-specific directories
-            'hooks/**', // Exclude hooks directory
+            'node_modules/**',
+            '*.zip',
+            'platforms/**',
+            'hooks/**',
         ];
         if (isUpdate) {
             ignorePatterns.push('**/assets/norrix.fingerprint.json');
@@ -702,7 +783,132 @@ async function zipProject(projectName, isUpdate = false) {
             cwd: process.cwd(),
             ignore: ignorePatterns,
         });
-        // Finalize the archive
+        archive.finalize();
+    });
+}
+/**
+ * Zip an Nx workspace project including the app and its dependencies
+ */
+async function zipWorkspaceProject(projectName, workspaceCtx, isUpdate = false, verbose = false) {
+    return new Promise((resolve, reject) => {
+        const outputPath = path.join(workspaceCtx.appRoot, `${projectName}.zip`);
+        const output = fs.createWriteStream(outputPath);
+        const archive = archiver('zip', {
+            zlib: { level: 9 },
+        });
+        output.on('close', () => {
+            resolve({ zipPath: outputPath, workspaceContext: workspaceCtx });
+        });
+        archive.on('warning', (err) => {
+            if (err.code === 'ENOENT') {
+                if (verbose)
+                    console.warn('Archive warning:', err);
+            }
+            else {
+                reject(err);
+            }
+        });
+        archive.on('error', (err) => {
+            reject(err);
+        });
+        archive.pipe(output);
+        logWorkspaceContext(workspaceCtx, verbose);
+        // Get workspace dependencies using Nx CLI (preferred) or fallback
+        let deps;
+        if (workspaceCtx.projectName) {
+            deps = getNxProjectDependencies(workspaceCtx.projectName, workspaceCtx.workspaceRoot, verbose);
+        }
+        if (!deps) {
+            if (verbose) {
+                console.log('[workspace] Using fallback dependency detection');
+            }
+            deps = getWorkspaceDependenciesFallback(workspaceCtx, verbose);
+        }
+        // Create manifest for CI
+        const manifest = createWorkspaceManifest(workspaceCtx, deps);
+        archive.append(JSON.stringify(manifest, null, 2), {
+            name: '.norrix/manifest.json',
+        });
+        // Base ignore patterns for the entire workspace
+        const ignorePatterns = [
+            '**/node_modules/**',
+            '**/*.zip',
+            '**/platforms/**',
+            '**/dist/**',
+            '**/.git/**',
+            '**/hooks/**',
+            // Exclude other apps (not the current one)
+            'apps/**',
+        ];
+        if (isUpdate) {
+            ignorePatterns.push('**/assets/norrix.fingerprint.json');
+        }
+        // 1. Add the app itself at its relative workspace path
+        console.log(`Adding app: ${workspaceCtx.relativeAppPath}`);
+        archive.directory(workspaceCtx.appRoot, workspaceCtx.relativeAppPath, (entry) => {
+            // Filter out node_modules, platforms, etc.
+            if (entry.name.includes('node_modules') ||
+                entry.name.includes('platforms') ||
+                entry.name.endsWith('.zip')) {
+                return false;
+            }
+            if (isUpdate && entry.name.includes('norrix.fingerprint.json')) {
+                return false;
+            }
+            return entry;
+        });
+        // 2. Add dependent libs
+        if (deps.libPaths.length > 0) {
+            console.log(`Adding ${deps.libPaths.length} library dependencies`);
+            for (const libPath of deps.libPaths) {
+                const absoluteLibPath = path.join(workspaceCtx.workspaceRoot, libPath);
+                if (fs.existsSync(absoluteLibPath)) {
+                    if (verbose) {
+                        console.log(`  - ${libPath}`);
+                    }
+                    archive.directory(absoluteLibPath, libPath, (entry) => {
+                        if (entry.name.includes('node_modules')) {
+                            return false;
+                        }
+                        return entry;
+                    });
+                }
+            }
+        }
+        // 3. Add root config files
+        console.log('Adding workspace root configuration files');
+        for (const configFile of deps.rootConfigs) {
+            const configPath = path.join(workspaceCtx.workspaceRoot, configFile);
+            if (fs.existsSync(configPath)) {
+                if (verbose) {
+                    console.log(`  - ${configFile}`);
+                }
+                archive.file(configPath, { name: configFile });
+            }
+        }
+        // 4. Add tools directory if it exists and is referenced
+        for (const toolPath of deps.toolPaths) {
+            const absoluteToolPath = path.join(workspaceCtx.workspaceRoot, toolPath);
+            if (fs.existsSync(absoluteToolPath) && fs.statSync(absoluteToolPath).isDirectory()) {
+                console.log(`Adding tools: ${toolPath}`);
+                archive.directory(absoluteToolPath, toolPath, (entry) => {
+                    if (entry.name.includes('node_modules')) {
+                        return false;
+                    }
+                    return entry;
+                });
+            }
+        }
+        // 5. Add asset paths if they exist
+        for (const assetPath of deps.assetPaths) {
+            const absoluteAssetPath = path.join(workspaceCtx.workspaceRoot, assetPath);
+            if (fs.existsSync(absoluteAssetPath) && fs.statSync(absoluteAssetPath).isDirectory()) {
+                if (verbose) {
+                    console.log(`Adding assets: ${assetPath}`);
+                }
+                archive.directory(absoluteAssetPath, assetPath);
+            }
+        }
         archive.finalize();
     });
 }
@@ -710,16 +916,33 @@ 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(cliPlatformArg, cliConfigurationArg, cliDistributionArg, verbose = false) {
+export async function build(cliPlatformArg, cliConfigurationArg, cliDistributionArg, verbose = false, options // string for backwards compatibility with old projectArg
+) {
+    // Normalize options - support both new object and legacy string projectArg
+    const opts = typeof options === 'string' ? { project: options } : (options || {});
     ensureInitialized();
     let spinner;
+    let originalCwd;
     try {
         spinner = ora('Preparing app for building...');
         spinner.start();
+        // 0. Resolve workspace context (handles --project and prompting)
+        const resolved = await resolveWorkspaceContext(opts.project, spinner);
+        originalCwd = resolved.originalCwd;
+        const workspaceCtx = resolved.workspaceContext;
+        // Restart spinner after potential prompts
+        if (!spinner.isSpinning) {
+            spinner.start('Preparing app for building...');
+        }
+        // Load Norrix config file if present
+        const norrixConfig = await loadNorrixConfig(process.cwd());
+        if (workspaceCtx.type === 'nx' && verbose) {
+            logWorkspaceContext(workspaceCtx, verbose);
+        }
         // 1. Get project info
         const projectName = await getProjectName();
-        // 2. Determine platform (CLI arg preferred, otherwise prompt)
-        let platform = (cliPlatformArg || '').toLowerCase();
+        // 2. Determine platform (CLI arg preferred, then config, otherwise prompt)
+        let platform = (cliPlatformArg || norrixConfig.defaultPlatform || '').toLowerCase();
         const validPlatforms = ['android', 'ios', 'visionos'];
         spinner.stop();
         if (!validPlatforms.includes(platform)) {
@@ -772,14 +995,20 @@ export async function build(cliPlatformArg, cliConfigurationArg, cliDistribution
             }
             return undefined;
         };
-        // 2.2 iOS distribution type (release only)
+        // 2.2 iOS distribution type (release only): CLI arg > config file > prompt
         let distributionType;
         if (platform === 'ios' && configuration === 'release') {
+            // Try CLI arg first
             distributionType = normalizeIosDistribution(cliDistributionArg);
             if (!distributionType && cliDistributionArg) {
                 throw new Error(`Invalid iOS distribution type '${cliDistributionArg}'. Use 'appstore', 'adhoc', or 'enterprise'.`);
             }
-            if (!distributionType) {
+            // Fall back to config file
+            if (!distributionType && norrixConfig.ios?.distributionType) {
+                distributionType = norrixConfig.ios.distributionType;
+            }
+            // Prompt if still not set (unless non-interactive mode)
+            if (!distributionType && !opts.nonInteractive) {
                 const { distribution } = await inquirer.prompt([
                     {
                         type: 'list',
@@ -795,6 +1024,10 @@ export async function build(cliPlatformArg, cliConfigurationArg, cliDistribution
                 ]);
                 distributionType = distribution;
             }
+            // Default to appstore in non-interactive mode if nothing else provided
+            if (!distributionType) {
+                distributionType = 'appstore';
+            }
         }
         const appleVersionInfo = platform === 'ios' || platform === 'visionos'
             ? getAppleVersionFromInfoPlist(platform)
@@ -865,7 +1098,31 @@ export async function build(cliPlatformArg, cliConfigurationArg, cliDistribution
         if (configuration === 'release') {
             spinner.stop();
             if (platform === 'ios') {
+                // Determine Team ID from: CLI flag > config file > prompt
+                const configTeamId = norrixConfig.ios?.teamId;
+                const resolvedTeamId = opts.teamId || configTeamId;
+                // If we have teamId from CLI or config, and non-interactive mode, skip prompts
+                const shouldPromptForTeamId = !resolvedTeamId && !opts.nonInteractive;
                 const iosAnswers = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'teamId',
+                        message: 'Apple Developer Team ID (required for code signing, e.g. "ABC123XYZ"):',
+                        default: resolvedTeamId || '',
+                        when: () => shouldPromptForTeamId || !resolvedTeamId,
+                        validate: (input) => {
+                            // Team ID is optional if user provides their own p12/profile
+                            // but we'll strongly recommend it
+                            if (!input.trim()) {
+                                return true; // Allow empty, workflow will try to proceed without it
+                            }
+                            // Basic validation: Apple Team IDs are typically 10 alphanumeric chars
+                            if (/^[A-Z0-9]{10}$/.test(input.trim())) {
+                                return true;
+                            }
+                            return 'Team ID should be 10 alphanumeric characters (e.g. "ABC123XYZ"). Leave empty to skip.';
+                        },
+                    },
                     {
                         type: 'input',
                         name: 'p12Path',
@@ -888,7 +1145,7 @@ export async function build(cliPlatformArg, cliConfigurationArg, cliDistribution
                     {
                         type: 'confirm',
                         name: 'hasAscKey',
-                        message: 'Provide App Store Connect API Key? (optional, for App Store operations)',
+                        message: 'Provide App Store Connect API Key? (optional, for auto-provisioning)',
                         default: false,
                     },
                     {
@@ -912,23 +1169,24 @@ export async function build(cliPlatformArg, cliConfigurationArg, cliDistribution
                         default: '',
                         when: (a) => a.hasAscKey,
                     },
-                    {
-                        type: 'input',
-                        name: 'ascTeamId',
-                        message: 'Apple Developer Team ID (optional, required for API-key provisioning):',
-                        default: '',
-                        when: (a) => a.hasAscKey,
-                    },
                 ]);
+                // Use resolved teamId from CLI/config, or from prompt
+                const finalTeamId = resolvedTeamId || iosAnswers.teamId?.trim();
                 iosCredentials = {
+                    teamId: finalTeamId || undefined,
                     p12Base64: readOptionalFileAsBase64(iosAnswers.p12Path),
                     p12Password: iosAnswers.p12Password || undefined,
                     mobileprovisionBase64: readOptionalFileAsBase64(iosAnswers.mobileprovisionPath),
                     ascApiKeyId: iosAnswers.ascApiKeyId || undefined,
                     ascIssuerId: iosAnswers.ascIssuerId || undefined,
                     ascPrivateKey: readOptionalFileAsBase64(iosAnswers.ascPrivateKeyPath),
-                    ascTeamId: iosAnswers.ascTeamId || undefined,
+                    // Track paths for config saving (not sent to API)
+                    _p12Path: iosAnswers.p12Path || undefined,
+                    _mobileprovisionPath: iosAnswers.mobileprovisionPath || undefined,
                 };
+                if (finalTeamId) {
+                    console.log(`Using Apple Team ID: ${finalTeamId}`);
+                }
             }
             else if (platform === 'android') {
                 const androidAnswers = await inquirer.prompt([
@@ -979,6 +1237,66 @@ export async function build(cliPlatformArg, cliConfigurationArg, cliDistribution
                     keyPassword: androidAnswers.keyPassword || undefined,
                     playServiceAccountJson: readOptionalFileAsBase64(androidAnswers.playJsonPath),
                 };
+                // Track Android paths for config saving
+                androidCredentials._keystorePath = androidAnswers.keystorePath || undefined;
+                androidCredentials._keyAlias = androidAnswers.keyAlias || undefined;
+            }
+            // Offer to save config if no norrix.config.ts exists and we collected useful values
+            const appRoot = process.cwd();
+            if (!hasNorrixConfig(appRoot) && !opts.nonInteractive) {
+                // Collect saveable values
+                const saveableOptions = {
+                    platform: platform,
+                };
+                if (platform === 'ios' && iosCredentials) {
+                    if (iosCredentials.teamId) {
+                        saveableOptions.teamId = iosCredentials.teamId;
+                    }
+                    if (distributionType) {
+                        saveableOptions.distributionType = distributionType;
+                    }
+                    // Don't save actual credential file paths since they may contain secrets
+                    // But save paths that users can re-use
+                    if (iosCredentials._p12Path) {
+                        saveableOptions.p12Path = iosCredentials._p12Path;
+                    }
+                    if (iosCredentials._mobileprovisionPath) {
+                        saveableOptions.provisioningProfilePath = iosCredentials._mobileprovisionPath;
+                    }
+                }
+                if (platform === 'android' && androidCredentials) {
+                    if (androidCredentials._keystorePath) {
+                        saveableOptions.keystorePath = androidCredentials._keystorePath;
+                    }
+                    if (androidCredentials._keyAlias) {
+                        saveableOptions.keyAlias = androidCredentials._keyAlias;
+                    }
+                }
+                // Only offer to save if we have something useful
+                const hasSaveableValues = saveableOptions.teamId ||
+                    saveableOptions.distributionType ||
+                    saveableOptions.p12Path ||
+                    saveableOptions.provisioningProfilePath ||
+                    saveableOptions.keystorePath;
+                if (hasSaveableValues) {
+                    const { shouldSave } = await inquirer.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'shouldSave',
+                            message: 'Save these settings to norrix.config.ts for future builds?',
+                            default: true,
+                        },
+                    ]);
+                    if (shouldSave) {
+                        try {
+                            const savedPath = saveNorrixConfig(appRoot, saveableOptions);
+                            console.log(`✓ Configuration saved to ${path.basename(savedPath)}`);
+                        }
+                        catch (saveError) {
+                            console.warn(`Warning: Could not save config file: ${saveError.message}`);
+                        }
+                    }
+                }
             }
             spinner.start('Creating project archive...');
         }
@@ -990,8 +1308,8 @@ export async function build(cliPlatformArg, cliConfigurationArg, cliDistribution
         });
         writeRuntimeFingerprintFile(projectRoot, fingerprint, platform);
         spinner.start('Creating project archive...');
-        // 3. Zip the project
-        const zipPath = await zipProject(projectName, false);
+        // 3. Zip the project (workspace-aware)
+        const { zipPath, workspaceContext } = await zipProject(projectName, false, verbose);
         spinner.text = 'Project archive created';
         // 4. Upload the project zip to S3
         spinner.text = 'Working...';
@@ -1018,6 +1336,12 @@ export async function build(cliPlatformArg, cliConfigurationArg, cliDistribution
         catch {
             inferredAppId = undefined;
         }
+        // Include workspace info for CI to properly navigate the project structure
+        const workspaceInfo = workspaceContext.type === 'nx' ? {
+            workspaceType: workspaceContext.type,
+            appPath: workspaceContext.relativeAppPath,
+            projectName: workspaceContext.projectName,
+        } : undefined;
         const response = await axios.post(`${API_URL}/build`, {
             projectName,
             appId: inferredAppId,
@@ -1031,6 +1355,8 @@ export async function build(cliPlatformArg, cliConfigurationArg, cliDistribution
             fingerprint,
             // Provide the relative key (without public/) – the workflow prepends public/
             s3Key: s3KeyRel,
+            // Workspace context for Nx monorepos
+            ...(workspaceInfo ? { workspace: workspaceInfo } : {}),
             // Only include raw credentials if not encrypted
             ...(encryptedSecrets ? { encryptedSecrets } : {}),
             ...(!encryptedSecrets && iosCredentials ? { iosCredentials } : {}),
@@ -1091,8 +1417,21 @@ export async function build(cliPlatformArg, cliConfigurationArg, cliDistribution
                     : 'App Store'}`);
         }
         console.log(`   You can check the status with: norrix build-status ${buildId}`);
+        // Restore original cwd if we changed it
+        if (originalCwd && process.cwd() !== originalCwd) {
+            process.chdir(originalCwd);
+        }
     }
     catch (error) {
+        // Restore original cwd if we changed it
+        if (originalCwd && process.cwd() !== originalCwd) {
+            try {
+                process.chdir(originalCwd);
+            }
+            catch {
+                // Ignore chdir errors during error handling
+            }
+        }
         const apiMessage = (error?.response?.data &&
             (error.response.data.error || error.response.data.message)) ||
             undefined;
@@ -1383,12 +1722,27 @@ export async function submit(cliPlatformArg, cliTrackArg, verbose = false) {
  * Update command implementation
  * Publishes over-the-air updates to deployed apps via the Next.js API gateway
  */
-export async function update(cliPlatformArg, cliVersionArg, verbose = false) {
+export async function update(cliPlatformArg, cliVersionArg, verbose = false, options // string for backwards compatibility with old projectArg
+) {
+    // Normalize options - support both new object and legacy string projectArg
+    const opts = typeof options === 'string' ? { project: options } : (options || {});
     ensureInitialized();
     let spinner;
+    let originalCwd;
     try {
         spinner = ora('Preparing over-the-air update...');
         spinner.start();
+        // 0. Resolve workspace context (handles --project and prompting)
+        const resolved = await resolveWorkspaceContext(opts.project, spinner);
+        originalCwd = resolved.originalCwd;
+        const workspaceCtx = resolved.workspaceContext;
+        // Restart spinner after potential prompts
+        if (!spinner.isSpinning) {
+            spinner.start('Preparing over-the-air update...');
+        }
+        if (workspaceCtx.type === 'nx' && verbose) {
+            logWorkspaceContext(workspaceCtx, verbose);
+        }
         // Normalize and/or ask for platform first (CLI arg takes precedence if valid)
         let platform = (cliPlatformArg || '').toLowerCase();
         const validPlatforms = ['android', 'ios', 'visionos'];
@@ -1424,27 +1778,45 @@ export async function update(cliPlatformArg, cliVersionArg, verbose = false) {
         // Ask for app ID and version first
         spinner.stop();
         const cliVersion = (cliVersionArg || '').trim();
-        const baseAnswers = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'appId',
-                message: 'Enter the App ID to update:',
-                default: inferredAppId || '',
-                validate: (input) => input.length > 0 || 'App ID is required',
-            },
-            {
-                type: 'input',
-                name: 'version',
-                message: inferredVersion
-                    ? `Update version (${inferredVersion}, enter to accept):`
-                    : 'Update version:',
-                default: inferredVersion,
-                when: () => !cliVersion,
-                validate: (input) => input.length > 0 || 'Version is required',
-            },
-        ]);
-        const appId = baseAnswers.appId;
-        const version = (cliVersion || baseAnswers.version);
+        // Resolve appId: CLI flag → inferred → prompt
+        let appId;
+        if (opts.appId) {
+            appId = opts.appId;
+        }
+        else {
+            const { appId: promptedAppId } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'appId',
+                    message: 'Enter the App ID to update:',
+                    default: inferredAppId || '',
+                    validate: (input) => input.length > 0 || 'App ID is required',
+                },
+            ]);
+            appId = promptedAppId;
+        }
+        // Resolve version: CLI arg → inferred → prompt
+        let version;
+        if (cliVersion) {
+            version = cliVersion;
+        }
+        else if (inferredVersion && opts.nonInteractive) {
+            version = inferredVersion;
+        }
+        else {
+            const { version: promptedVersion } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'version',
+                    message: inferredVersion
+                        ? `Update version (${inferredVersion}, enter to accept):`
+                        : 'Update version:',
+                    default: inferredVersion,
+                    validate: (input) => input.length > 0 || 'Version is required',
+                },
+            ]);
+            version = promptedVersion;
+        }
         // Ask the server what the next buildNumber would be for this app so we
         // can present a sensible default in the prompt, matching what the API
         // will auto-increment to if left blank.
@@ -1468,38 +1840,51 @@ export async function update(cliPlatformArg, cliVersionArg, verbose = false) {
             : platform === 'android'
                 ? androidVersionInfo.buildNumber
                 : undefined;
-        const { buildNumber: promptedBuildNumber, notes } = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'buildNumber',
-                message: (() => {
-                    if (serverSuggestedBuildNumber) {
-                        return `Update build number (${serverSuggestedBuildNumber}, enter to accept or override; blank to auto increment from server):`;
-                    }
-                    if (localInferredBuildNumber) {
-                        return `Update build number (${localInferredBuildNumber}, enter to auto increment from server):`;
-                    }
-                    return 'Update build number (leave blank to auto increment from server):';
-                })(),
-                default: serverSuggestedBuildNumber || localInferredBuildNumber || '',
-                validate: (input) => {
-                    const val = String(input).trim();
-                    if (!val)
-                        return true; // allow blank -> server will auto-increment
-                    if (!/^\d+$/.test(val)) {
-                        return 'Build number must be a positive integer or blank to auto-increment';
-                    }
-                    return true;
+        // Resolve buildNumber: CLI flag → server suggestion → local inferred → prompt
+        let buildNumber;
+        let notes = '';
+        if (opts.buildNumber) {
+            buildNumber = opts.buildNumber;
+        }
+        else if (opts.nonInteractive) {
+            // In non-interactive mode, use server suggestion or leave undefined for auto-increment
+            buildNumber = serverSuggestedBuildNumber || localInferredBuildNumber || undefined;
+        }
+        else {
+            const buildPromptAnswers = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'buildNumber',
+                    message: (() => {
+                        if (serverSuggestedBuildNumber) {
+                            return `Update build number (${serverSuggestedBuildNumber}, enter to accept or override; blank to auto increment from server):`;
+                        }
+                        if (localInferredBuildNumber) {
+                            return `Update build number (${localInferredBuildNumber}, enter to auto increment from server):`;
+                        }
+                        return 'Update build number (leave blank to auto increment from server):';
+                    })(),
+                    default: serverSuggestedBuildNumber || localInferredBuildNumber || '',
+                    validate: (input) => {
+                        const val = String(input).trim();
+                        if (!val)
+                            return true; // allow blank -> server will auto-increment
+                        if (!/^\d+$/.test(val)) {
+                            return 'Build number must be a positive integer or blank to auto-increment';
+                        }
+                        return true;
+                    },
                 },
-            },
-            {
-                type: 'input',
-                name: 'notes',
-                message: 'Release notes (optional):',
-                default: '',
-            },
-        ]);
-        const buildNumber = String(promptedBuildNumber || '').trim() || undefined;
+                {
+                    type: 'input',
+                    name: 'notes',
+                    message: 'Release notes (optional):',
+                    default: '',
+                },
+            ]);
+            buildNumber = String(buildPromptAnswers.buildNumber || '').trim() || undefined;
+            notes = buildPromptAnswers.notes || '';
+        }
         // Check the app directory structure before packaging
         const srcAppDir = path.join(process.cwd(), 'src', 'app');
         const appDir = path.join(process.cwd(), 'app');
@@ -1576,9 +1961,9 @@ export async function update(cliPlatformArg, cliVersionArg, verbose = false) {
         // fingerprint JSON under the app source tree is the
         // single source of truth for OTA compatibility.
         spinner.start('Packaging for over-the-air update...');
-        // Create the update bundle - pass true to include node_modules for updates
+        // Create the update bundle (workspace-aware) - pass true to include node_modules for updates
         const projectName = await getProjectName();
-        const zipPath = await zipProject(projectName, true);
+        const { zipPath, workspaceContext } = await zipProject(projectName, true, verbose);
         spinner.text = 'Uploading update to Norrix cloud storage...';
         const fileBuffer = fs.readFileSync(zipPath);
         const updateFolder = `update-${Date.now()}`;
@@ -1586,6 +1971,12 @@ export async function update(cliPlatformArg, cliVersionArg, verbose = false) {
         const s3KeyRel = `updates/${updateFolder}/${appId}-${safeVersion}.zip`;
         await putObjectToStorage(`public/${s3KeyRel}`, fileBuffer);
         spinner.text = 'Upload complete. Starting update...';
+        // Include workspace info for CI to properly navigate the project structure
+        const workspaceInfo = workspaceContext.type === 'nx' ? {
+            workspaceType: workspaceContext.type,
+            appPath: workspaceContext.relativeAppPath,
+            projectName: workspaceContext.projectName,
+        } : undefined;
         const response = await axios.post(`${API_URL}/update`, {
             appId,
             platform,
@@ -1595,6 +1986,8 @@ export async function update(cliPlatformArg, cliVersionArg, verbose = false) {
             fingerprint,
             // Provide the relative key (without public/). Consumers will prepend public/
             s3Key: s3KeyRel,
+            // Workspace context for Nx monorepos
+            ...(workspaceInfo ? { workspace: workspaceInfo } : {}),
         }, {
             headers: {
                 'Content-Type': 'application/json',
@@ -1644,8 +2037,21 @@ export async function update(cliPlatformArg, cliVersionArg, verbose = false) {
         }
         console.log(formatVersionBuildLine(recordedUpdateVersion, recordedUpdateBuildNumber));
         console.log(`   You can check the status with: norrix update-status ${updateId}`);
+        // Restore original cwd if we changed it
+        if (originalCwd && process.cwd() !== originalCwd) {
+            process.chdir(originalCwd);
+        }
     }
     catch (error) {
+        // Restore original cwd if we changed it
+        if (originalCwd && process.cwd() !== originalCwd) {
+            try {
+                process.chdir(originalCwd);
+            }
+            catch {
+                // Ignore chdir errors during error handling
+            }
+        }
         const apiMessage = (error?.response?.data &&
             (error.response.data.error || error.response.data.message)) ||
             undefined;