@magentrix-corp/magentrix-cli 1.3.3 → 1.3.5

package/README.md

@@ -491,32 +491,38 @@ magentrix vue-build-stage
 ```
 **What it does**: Builds a linked Vue project and copies the output to `src/iris-apps/<slug>/` for publishing.
 
+**Two modes of operation:**
+
+1. **From Magentrix workspace**: Prompts for which Vue project to build, stages to current workspace
+2. **From Vue project directory**: Prompts for which Magentrix workspace to stage into
+
 **Options:**
 - `--path <dir>` - Specify Vue project path directly
 - `--skip-build` - Use existing `dist/` folder without rebuilding
+- `--workspace <dir>` - Specify Magentrix workspace path directly (when running from Vue project)
 
 **Process:**
 1. Select from linked projects or enter path manually
 2. Run `npm run build` in the Vue project
 3. Validate the build output
-4. Copy to CLI workspace `src/iris-apps/<app-slug>/`
+4. Copy to workspace `src/iris-apps/<app-slug>/`
 
 #### Vue Development Server
 ```bash
-magentrix iris-dev
+magentrix run-dev
 ```
 **What it does**: Starts the Vue development server with platform assets (CSS, fonts) automatically injected from your Magentrix instance.
 
+**Authentication**: Uses `VITE_REFRESH_TOKEN` from `.env.development` (no CLI authentication required). This command can be run inside the Vue project directory.
+
 **Options:**
 - `--path <dir>` - Specify Vue project path
 - `--no-inject` - Skip asset injection, just run dev server
-- `--restore` - Restore `.env.development` from backup without running
 
 **Process:**
-1. Fetch platform assets from Magentrix
-2. Backup `.env.development` and inject assets
+1. Fetch platform assets from Magentrix using `.env.development` credentials
+2. Update `VITE_ASSETS` in `.env.development` (changes are kept)
 3. Run `npm run dev`
-4. Restore `.env.development` on exit (Ctrl+C)
 
 #### Delete an Iris App
 ```bash
@@ -577,7 +583,7 @@ export const config = {
 ```bash
 VITE_SITE_URL = https://yourinstance.magentrix.com
 VITE_REFRESH_TOKEN = your-api-key
-VITE_ASSETS = '[]'  # Injected automatically by iris-dev
+VITE_ASSETS = '[]'  # Injected automatically by run-dev
 ```
 
 **Accepted field names in config.ts:**
@@ -586,28 +592,48 @@ VITE_ASSETS = '[]'  # Injected automatically by iris-dev
 - Description: `appDescription` or `app_description`
 - Icon: `appIconId` or `app_icon_id`
 
+### Command Availability
+
+**In Vue project directories** (detected by presence of `config.ts`):
+- ✓ `magentrix iris-link` - Link project to CLI
+- ✓ `magentrix vue-build-stage` - Build and stage (prompts for target workspace)
+- ✓ `magentrix run-dev` - Start dev server (uses `.env.development` credentials)
+- ✓ `magentrix update` - Update CLI to latest version
+
+**In Magentrix workspace directories** (has `.magentrix/` folder):
+- ✓ All standard commands (`setup`, `pull`, `publish`, etc.)
+- ✓ All Iris commands (`vue-build-stage`, `iris-delete`, `iris-recover`, etc.)
+
+**Note**: The `setup` command cannot be run inside a Vue project directory - run it from your Magentrix workspace. Commands like `pull`, `publish`, `autopublish` require a Magentrix workspace.
+
 ### Typical Development Workflow
 
 ```bash
 # First time setup
 magentrix iris-link           # Link your Vue project
 
-# Development
-magentrix iris-dev            # Start dev server with platform assets
+# Development (run from Vue project folder)
+cd ~/my-vue-app               # Work from your Vue project
+magentrix run-dev             # Start dev server with platform assets
 # Make changes, test locally
 # Press Ctrl+C to stop
 
-# Deployment (run from Magentrix workspace, not Vue project folder)
+# Deployment - Option A (from Vue project folder)
+cd ~/my-vue-app               # Work from your Vue project
+magentrix vue-build-stage     # Build and select workspace to stage into
+# Follow prompts, then navigate to workspace to publish
+
+# Deployment - Option B (from Magentrix workspace)
 cd ~/magentrix-workspace      # Navigate to Magentrix workspace
 magentrix vue-build-stage --path ~/my-vue-app  # Build and stage
 # Prompted: "Do you want to publish to Magentrix now?" → Yes/No
 # If autopublish is running, it auto-deploys instead
 
-# Deleting an app
+# Deleting an app (from workspace)
 magentrix iris-delete         # Select app, confirm, auto-backup created
 magentrix publish             # Sync deletion to server
 
-# Recovering a deleted app
+# Recovering a deleted app (from workspace)
 magentrix iris-recover        # Select backup, restore files
 magentrix publish             # Sync recovery to server
 ```
@@ -627,29 +653,31 @@ magentrix vue-build-stage
 
 ### Troubleshooting Iris Apps
 
-#### "Warning: Magentrix Workspace Not Detected"
-This warning appears when running `magentrix vue-build-stage` outside your Magentrix CLI workspace.
+#### Running vue-build-stage from different locations
 
-**Why it happens:**
-- The command stages build files to `src/iris-apps/<slug>/` in your Magentrix workspace
-- You ran it from your Vue project directory or another location
+The `vue-build-stage` command works from both locations:
 
-**How to fix:**
-1. Navigate to your Magentrix CLI workspace (the folder with `.magentrix/` and `src/`)
-2. Run the command from there
-3. Use `--path` to specify your Vue project: `magentrix vue-build-stage --path /path/to/vue-project`
-
-**Example:**
+**From Vue project directory:**
 ```bash
-# Wrong - running from Vue project
 cd ~/my-vue-app
-magentrix vue-build-stage  # ⚠ Warning!
+magentrix vue-build-stage  # Prompts for which workspace to stage into
+```
 
-# Right - running from Magentrix workspace
+**From Magentrix workspace:**
+```bash
 cd ~/magentrix-workspace
-magentrix vue-build-stage --path ~/my-vue-app  # ✓ Works!
+magentrix vue-build-stage  # Prompts for which Vue project to build
+# Or with path: magentrix vue-build-stage --path ~/my-vue-app
 ```
 
+#### "No Magentrix workspaces found"
+When running from a Vue project, the command looks for registered workspaces in the global config. To register a workspace:
+1. Navigate to your Magentrix workspace
+2. Run `magentrix setup` (this automatically registers it)
+3. Or specify workspace manually: `magentrix vue-build-stage --workspace /path/to/workspace`
+
+**Note**: Existing workspaces are auto-registered when you run any command from them.
+
 #### "Missing required field in config.ts: slug (appPath)"
 Your Vue project's `config.ts` is missing the app identifier. Add an `appPath` or `slug` field.
 
@@ -751,16 +779,24 @@ magentrix status        # Verify everything is in sync
 ```
 
 ### Deploying a Vue.js App
-```bash
-# Important: Run from your Magentrix CLI workspace, NOT the Vue project folder
-cd ~/magentrix-workspace      # Navigate to Magentrix workspace
 
+**Option A: From Vue project folder**
+```bash
+cd ~/my-vue-app               # Navigate to your Vue project
 magentrix iris-link           # Link project (first time only)
+magentrix vue-build-stage     # Build and select workspace to stage into
+# Navigate to workspace and run: magentrix publish
+```
+
+**Option B: From Magentrix workspace**
+```bash
+cd ~/magentrix-workspace      # Navigate to Magentrix workspace
+magentrix iris-link --path ~/my-vue-app  # Link project (first time only)
 magentrix vue-build-stage --path ~/my-vue-app  # Build and stage
 # Prompted: "Do you want to publish to Magentrix now?" (unless autopublish is running)
 ```
 
-**Note:** The `vue-build-stage` command must be run from your Magentrix CLI workspace directory (where `.magentrix/` and `src/` folders are). Use `--path` to specify your Vue project location.
+**Note:** When running from a Vue project, the command prompts you to select a registered workspace. Workspaces are auto-registered when you run any command from them.
 
 ### Deleting and Recovering Apps
 ```bash
@@ -1058,7 +1094,7 @@ magentrix status        # Shows sync status
 - `magentrix update` - Update to latest version
 - `magentrix iris-link` - Link Vue.js projects for deployment
 - `magentrix vue-build-stage` - Build and stage Vue.js apps
-- `magentrix iris-dev` - Start Vue dev server with platform assets
+- `magentrix run-dev` - Start Vue dev server with platform assets
 - `magentrix iris-delete` - Delete an Iris app with recovery backup
 - `magentrix iris-recover` - Recover a deleted Iris app
 
@@ -1072,6 +1108,6 @@ Once you're comfortable with basic usage:
 2. **Learn the autopublish workflow** for faster development
 3. **Explore conflict resolution** if you work in a team
 4. **Check out templates** created by the `create` command to understand best practices
-5. **Deploy Vue.js apps** using `iris-link`, `vue-build-stage`, and `iris-dev` commands
+5. **Deploy Vue.js apps** using `iris-link`, `vue-build-stage`, and `run-dev` commands
 
 Happy coding with MagentrixCLI! 🚀

package/actions/iris/buildStage.js

@@ -2,12 +2,13 @@ import chalk from 'chalk';
 import { select, input, confirm } from '@inquirer/prompts';
 import { existsSync } from 'node:fs';
 import { resolve, join } from 'node:path';
+import { spawn } from 'node:child_process';
 import Config from '../../utils/config.js';
 import { runPublish } from '../publish.js';
 import { isAutopublishRunning } from '../../utils/autopublishLock.js';
 import {
     buildVueProject,
-    stageToCliProject,
+    stageToWorkspace,
     findDistDirectory,
     formatBuildError,
     formatValidationError
@@ -25,9 +26,24 @@ import {
     buildProjectChoices
 } from '../../utils/iris/linker.js';
 import { EXPORT_ROOT, IRIS_APPS_DIR, HASHED_CWD } from '../../vars/global.js';
+import { getValidWorkspaces } from '../../utils/workspaces.js';
 
 const config = new Config();
 
+/**
+ * Check if the current directory is a Vue project (has config.ts).
+ * @returns {boolean}
+ */
+function isInVueProject() {
+    const configLocations = [
+        'src/config.ts',
+        'config.ts',
+        'src/iris-config.ts',
+        'iris-config.ts'
+    ];
+    return configLocations.some(loc => existsSync(join(process.cwd(), loc)));
+}
+
 /**
  * Check if the current directory appears to be a Magentrix workspace.
  * @returns {boolean} - True if in a Magentrix workspace
@@ -52,17 +68,33 @@ function isMagentrixWorkspace() {
 /**
  * vue-build-stage command - Build a Vue project and stage to CLI workspace.
  *
+ * Two modes of operation:
+ * 1. Run from Magentrix workspace: prompts for which Vue project to build
+ * 2. Run from Vue project: prompts for which workspace to stage into
+ *
  * Options:
- *   --path <dir>      Specify Vue project path directly
- *   --skip-build      Use existing dist/ without rebuilding
+ *   --path <dir>        Specify Vue project path directly
+ *   --skip-build        Use existing dist/ without rebuilding
+ *   --workspace <dir>   Specify Magentrix workspace path directly
  */
 export const vueBuildStage = async (options = {}) => {
     process.stdout.write('\x1Bc'); // Clear console
 
-    const { path: pathOption, skipBuild } = options;
+    const { path: pathOption, skipBuild, workspace: workspaceOption } = options;
+
+    // Detect which mode we're in
+    const inVueProject = isInVueProject();
+    const inWorkspace = isMagentrixWorkspace();
 
+    // If run from a Vue project, use reversed logic
+    if (inVueProject && !inWorkspace) {
+        await buildFromVueProject(options);
+        return;
+    }
+
+    // Standard mode: run from workspace, select Vue project
     // Warn if not in a Magentrix workspace
-    if (!isMagentrixWorkspace()) {
+    if (!inWorkspace) {
         console.log(chalk.yellow('⚠ Warning: Magentrix Workspace Not Detected'));
         console.log(chalk.gray('─'.repeat(48)));
         console.log(chalk.white('\nThis command should be run from your Magentrix CLI workspace directory.'));
@@ -200,11 +232,11 @@ export const vueBuildStage = async (options = {}) => {
         console.log(chalk.green('\u2713 Build output validated'));
     }
 
-    // Stage to CLI project
+    // Stage to CLI project (current workspace)
     console.log();
     console.log(chalk.blue('Staging to CLI workspace...'));
 
-    const stageResult = stageToCliProject(distPath, slug);
+    const stageResult = stageToWorkspace(distPath, slug, process.cwd());
 
     if (!stageResult.success) {
         console.log(chalk.red(`Failed to stage: ${stageResult.error}`));
@@ -251,6 +283,295 @@ export const vueBuildStage = async (options = {}) => {
     }
 };
 
+/**
+ * Build and stage when running from inside a Vue project.
+ * Prompts user to select which workspace to stage into.
+ */
+async function buildFromVueProject(options) {
+    const { skipBuild, workspace: workspaceOption } = options;
+
+    // Use current directory as Vue project
+    const projectPath = process.cwd();
+    const vueConfig = readVueConfig(projectPath);
+
+    // Validate Vue config
+    if (!vueConfig.found) {
+        console.log(chalk.red(formatMissingConfigError(projectPath)));
+        return;
+    }
+
+    if (vueConfig.errors.length > 0) {
+        console.log(chalk.red(formatConfigErrors(vueConfig)));
+        return;
+    }
+
+    const { slug, appName } = vueConfig;
+
+    console.log(chalk.blue('\nVue Build & Stage'));
+    console.log(chalk.gray('─'.repeat(48)));
+    console.log(chalk.white(`  Project: ${chalk.cyan(appName)} (${slug})`));
+    console.log(chalk.white(`  Path: ${chalk.gray(projectPath)}`));
+    console.log();
+
+    // Determine which workspace to stage into
+    let workspacePath = workspaceOption;
+
+    if (workspacePath) {
+        workspacePath = resolve(workspacePath);
+        if (!existsSync(workspacePath)) {
+            console.log(chalk.red(`Error: Workspace path does not exist: ${workspacePath}`));
+            return;
+        }
+    } else {
+        // Prompt user to select a workspace
+        const result = await selectWorkspace();
+        if (!result) return; // User cancelled
+        workspacePath = result;
+    }
+
+    // Ensure project is linked
+    const linked = findLinkedProjectByPath(projectPath);
+    if (!linked) {
+        const shouldLink = await confirm({
+            message: 'This project is not linked. Link it now?',
+            default: true
+        });
+
+        if (shouldLink) {
+            const linkResult = linkVueProject(projectPath);
+            if (!linkResult.success) {
+                console.log(chalk.red(`Failed to link project: ${linkResult.error}`));
+                return;
+            }
+            console.log(chalk.green(`\u2713 Project linked`));
+        }
+    }
+
+    let distPath;
+
+    if (skipBuild) {
+        // Use existing dist
+        distPath = findDistDirectory(projectPath);
+
+        if (!distPath) {
+            console.log(chalk.red('No existing dist/ directory found.'));
+            console.log(chalk.gray('Run without --skip-build to build the project.'));
+            return;
+        }
+
+        console.log(chalk.yellow(`Using existing dist: ${distPath}`));
+
+        // Validate the existing build
+        const validation = validateIrisBuild(distPath);
+        if (!validation.valid) {
+            console.log(chalk.red(formatValidationError(distPath, validation.errors)));
+            return;
+        }
+
+        console.log(chalk.green('\u2713 Existing build is valid'));
+    } else {
+        // Build the project
+        console.log(chalk.blue('Building project...'));
+        console.log();
+
+        const buildResult = await buildVueProject(projectPath, { silent: false });
+
+        if (!buildResult.success) {
+            console.log();
+            console.log(chalk.red(formatBuildError(projectPath, buildResult.error)));
+            return;
+        }
+
+        distPath = buildResult.distPath;
+        console.log();
+        console.log(chalk.green(`\u2713 Build completed successfully`));
+        console.log(chalk.gray(`  Output: ${distPath}`));
+
+        // Validate build output
+        const validation = validateIrisBuild(distPath);
+        if (!validation.valid) {
+            console.log();
+            console.log(chalk.red(formatValidationError(distPath, validation.errors)));
+            return;
+        }
+
+        console.log(chalk.green('\u2713 Build output validated'));
+    }
+
+    // Stage to selected workspace
+    console.log();
+    console.log(chalk.blue(`Staging to workspace: ${workspacePath}`));
+
+    const stageResult = stageToWorkspace(distPath, slug, workspacePath);
+
+    if (!stageResult.success) {
+        console.log(chalk.red(`Failed to stage: ${stageResult.error}`));
+        return;
+    }
+
+    console.log(chalk.green(`\u2713 Staged ${stageResult.fileCount} files to ${stageResult.stagedPath}`));
+
+    // Summary
+    console.log();
+    console.log(chalk.green('─'.repeat(48)));
+    console.log(chalk.green.bold('\u2713 Build & Stage Complete!'));
+    console.log();
+    console.log(chalk.gray(`Staged to: ${stageResult.stagedPath}`));
+    console.log();
+
+    // Ask if they want to publish now
+    const shouldPublish = await confirm({
+        message: 'Do you want to publish to Magentrix now?',
+        default: true
+    });
+
+    if (shouldPublish) {
+        console.log();
+        console.log(chalk.blue('Running publish from workspace...'));
+        console.log();
+
+        const publishSuccess = await runPublishFromWorkspace(workspacePath);
+
+        if (!publishSuccess) {
+            console.log();
+            console.log(chalk.cyan('To publish manually:'));
+            console.log(chalk.white(`  1. Navigate to workspace: ${chalk.yellow(`cd "${workspacePath}"`)}`));
+            console.log(chalk.white(`  2. Run ${chalk.yellow('magentrix publish')}`));
+        }
+    } else {
+        console.log();
+        console.log(chalk.cyan('Next steps:'));
+        console.log(chalk.white(`  1. Navigate to workspace: ${chalk.yellow(`cd "${workspacePath}"`)}`));
+        console.log(chalk.white(`  2. Run ${chalk.yellow('magentrix publish')} to deploy to Magentrix`));
+        console.log(chalk.white(`     Or use ${chalk.yellow('magentrix autopublish')} for automatic deployment`));
+    }
+}
+
+/**
+ * Run magentrix publish from a specific workspace directory.
+ *
+ * @param {string} workspacePath - Path to the Magentrix workspace
+ * @returns {Promise<boolean>} - True if publish succeeded
+ */
+async function runPublishFromWorkspace(workspacePath) {
+    return new Promise((resolvePromise) => {
+        const isWindows = process.platform === 'win32';
+        const npmCmd = isWindows ? 'npx.cmd' : 'npx';
+
+        const child = spawn(npmCmd, ['magentrix', 'publish'], {
+            cwd: workspacePath,
+            stdio: 'inherit',
+            shell: isWindows
+        });
+
+        child.on('close', (code) => {
+            resolvePromise(code === 0);
+        });
+
+        child.on('error', (err) => {
+            console.log(chalk.yellow(`Warning: Could not run publish: ${err.message}`));
+            resolvePromise(false);
+        });
+    });
+}
+
+/**
+ * Prompt user to select a Magentrix workspace.
+ *
+ * @returns {Promise<string | null>} - Selected workspace path or null if cancelled
+ */
+async function selectWorkspace() {
+    const workspaces = getValidWorkspaces();
+
+    if (workspaces.length === 0) {
+        console.log(chalk.yellow('No Magentrix workspaces found.'));
+        console.log();
+        console.log(chalk.gray('To register a workspace:'));
+        console.log(chalk.white(`  • Run ${chalk.cyan('magentrix')} from an existing workspace (auto-registers it)`));
+        console.log(chalk.white(`  • Or run ${chalk.cyan('magentrix setup')} in a new directory to create one`));
+        console.log();
+        console.log(chalk.gray('Or specify a workspace path directly:'));
+        console.log(chalk.white(`  ${chalk.cyan('magentrix vue-build-stage --workspace /path/to/workspace')}`));
+        console.log();
+
+        // Allow manual entry
+        const manualPath = await input({
+            message: 'Enter the path to your Magentrix workspace (or leave empty to cancel):',
+            validate: (value) => {
+                if (!value.trim()) return true; // Allow empty for cancel
+                const resolved = resolve(value);
+                if (!existsSync(resolved)) {
+                    return `Path does not exist: ${resolved}`;
+                }
+                const magentrixFolder = join(resolved, '.magentrix');
+                if (!existsSync(magentrixFolder)) {
+                    return `Not a Magentrix workspace (missing .magentrix folder): ${resolved}`;
+                }
+                return true;
+            }
+        });
+
+        if (!manualPath.trim()) {
+            console.log(chalk.gray('Cancelled.'));
+            return null;
+        }
+
+        return resolve(manualPath);
+    }
+
+    // Build choices from registered workspaces
+    const choices = workspaces.map(w => ({
+        name: `${w.path}`,
+        value: w.path,
+        description: chalk.dim(`→ ${w.instanceUrl}`)
+    }));
+
+    choices.push({
+        name: 'Enter path manually',
+        value: '__manual__',
+        description: chalk.dim('→ Specify the full path to a workspace')
+    });
+
+    choices.push({
+        name: 'Cancel',
+        value: '__cancel__'
+    });
+
+    const choice = await select({
+        message: 'Which workspace do you want to stage into?',
+        choices
+    });
+
+    if (choice === '__cancel__') {
+        console.log(chalk.gray('Cancelled.'));
+        return null;
+    }
+
+    if (choice === '__manual__') {
+        const manualPath = await input({
+            message: 'Enter the path to your Magentrix workspace:',
+            validate: (value) => {
+                if (!value.trim()) {
+                    return 'Path is required';
+                }
+                const resolved = resolve(value);
+                if (!existsSync(resolved)) {
+                    return `Path does not exist: ${resolved}`;
+                }
+                const magentrixFolder = join(resolved, '.magentrix');
+                if (!existsSync(magentrixFolder)) {
+                    return `Not a Magentrix workspace (missing .magentrix folder): ${resolved}`;
+                }
+                return true;
+            }
+        });
+
+        return resolve(manualPath);
+    }
+
+    return choice;
+}
+
 /**
  * Prompt user to select a project.
  *

package/actions/iris/dev.js

@@ -7,8 +7,6 @@ import {
     readVueConfig,
     formatMissingConfigError,
     formatConfigErrors,
-    backupFile,
-    restoreFile,
     injectAssets,
     getInjectionTarget
 } from '../../utils/iris/config-reader.js';
@@ -20,26 +18,19 @@ import {
 } from '../../utils/iris/linker.js';
 
 /**
- * iris-dev command - Start Vue dev server with platform assets injected.
+ * run-dev command - Start Vue dev server with platform assets injected.
  *
- * Assets are injected into .env.development (if exists) or config.ts.
- * The modified file is backed up and restored when the dev server exits.
+ * Uses credentials from .env.development (VITE_REFRESH_TOKEN, VITE_SITE_URL).
+ * Assets are updated in .env.development (VITE_ASSETS) and kept between runs.
  *
  * Options:
  *   --path <dir>      Specify Vue project path
  *   --no-inject       Skip asset injection, just run dev server
- *   --restore         Restore .env.development or config.ts from backup
  */
 export const irisDev = async (options = {}) => {
     process.stdout.write('\x1Bc'); // Clear console
 
-    const { path: pathOption, inject = true, restore } = options;
-
-    // Handle --restore option
-    if (restore) {
-        await handleRestore(pathOption);
-        return;
-    }
+    const { path: pathOption, inject = true } = options;
 
     // Determine which project to use
     let projectPath = pathOption;
@@ -93,11 +84,6 @@ export const irisDev = async (options = {}) => {
     }
     console.log();
 
-    let backupPath = null;
-    let assetsInjected = false;
-    let modifiedFilePath = null;
-    let modifiedFileName = null;
-
     // Inject assets if enabled
     if (inject && siteUrl) {
         // Check if we have the refresh token for authentication
@@ -116,27 +102,18 @@ export const irisDev = async (options = {}) => {
                     console.log(chalk.green(`\u2713 Found ${assetsResult.assets.length} platform assets`));
 
                     // Determine which file will be modified
-                    const { targetFile, targetName } = getInjectionTarget(projectPath);
+                    const { targetFile } = getInjectionTarget(projectPath);
 
                     if (!targetFile) {
                         console.log(chalk.yellow('Warning: No .env.development file found. Cannot inject assets.'));
                         console.log(chalk.gray('Create a .env.development file to enable asset injection.'));
                     } else {
-                        modifiedFilePath = targetFile;
-                        modifiedFileName = targetName;
-
-                        // Backup before modifying
-                        console.log(chalk.blue(`Backing up ${modifiedFileName}...`));
-                        backupPath = backupFile(modifiedFilePath);
-                        console.log(chalk.green(`\u2713 Backup created`));
-
-                        // Inject assets
-                        console.log(chalk.blue('Injecting assets...'));
+                        // Inject assets (no backup needed - we keep the changes)
+                        console.log(chalk.blue('Updating assets in .env.development...'));
                         const injectResult = injectAssets(projectPath, assetsResult.assets);
 
                         if (injectResult.success) {
-                            assetsInjected = true;
-                            console.log(chalk.green(`\u2713 Assets injected into ${injectResult.targetName}`));
+                            console.log(chalk.green(`\u2713 Assets updated in ${injectResult.targetName}`));
                         } else {
                             console.log(chalk.yellow('Warning: Could not inject assets. Continuing without injection.'));
                         }
@@ -165,50 +142,34 @@ export const irisDev = async (options = {}) => {
     console.log(chalk.gray('Press Ctrl+C to stop'));
     console.log();
 
-    await runDevServer(projectPath, modifiedFilePath, modifiedFileName, backupPath, assetsInjected);
+    await runDevServer(projectPath);
 };
 
 /**
  * Run the Vue development server.
  */
-async function runDevServer(projectPath, modifiedFilePath, modifiedFileName, backupPath, assetsInjected) {
+async function runDevServer(projectPath) {
     return new Promise((resolvePromise) => {
-        const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+        const isWindows = process.platform === 'win32';
+        const npmCmd = isWindows ? 'npm.cmd' : 'npm';
 
         const child = spawn(npmCmd, ['run', 'dev'], {
             cwd: projectPath,
             stdio: 'inherit',
-            shell: false
+            shell: isWindows  // Windows requires shell: true for .cmd files
         });
 
-        // Handle cleanup on exit
-        const cleanup = () => {
-            if (assetsInjected && backupPath && modifiedFilePath) {
-                console.log();
-                console.log(chalk.blue(`Restoring ${modifiedFileName} from backup...`));
-                const restored = restoreFile(modifiedFilePath);
-                if (restored) {
-                    console.log(chalk.green(`\u2713 ${modifiedFileName} restored`));
-                } else {
-                    console.log(chalk.yellow(`Warning: Could not restore ${modifiedFileName}`));
-                    console.log(chalk.gray(`Backup is at: ${backupPath}`));
-                }
-            }
-        };
-
         // Handle process signals
         process.on('SIGINT', () => {
-            cleanup();
             child.kill('SIGINT');
         });
 
         process.on('SIGTERM', () => {
-            cleanup();
             child.kill('SIGTERM');
         });
 
         child.on('close', (code) => {
-            // If dev server exited with error, show helpful context first
+            // If dev server exited with error, show helpful context
             if (code !== 0 && code !== null) {
                 console.log();
                 console.log(chalk.bgYellow.black(' External Process Error '));
@@ -227,59 +188,16 @@ async function runDevServer(projectPath, modifiedFilePath, modifiedFileName, bac
                 console.log(chalk.yellow('─'.repeat(48)));
             }
 
-            // Cleanup after showing error context
-            cleanup();
-
             resolvePromise(code);
         });
 
         child.on('error', (err) => {
             console.log(chalk.red(`Failed to start dev server: ${err.message}`));
-            cleanup();
             resolvePromise(1);
         });
     });
 }
 
-/**
- * Handle --restore option.
- */
-async function handleRestore(pathOption) {
-    let projectPath = pathOption;
-
-    if (!projectPath) {
-        // Try current directory
-        const cwdConfig = readVueConfig(process.cwd());
-        if (cwdConfig.found) {
-            projectPath = process.cwd();
-        } else {
-            console.log(chalk.red('No Vue project found in current directory.'));
-            console.log(chalk.gray('Use --path to specify the project path.'));
-            return;
-        }
-    }
-
-    projectPath = resolve(projectPath);
-
-    // Determine which file would be the injection target
-    const { targetFile, targetName } = getInjectionTarget(projectPath);
-
-    if (!targetFile) {
-        console.log(chalk.yellow('No config files found to restore.'));
-        return;
-    }
-
-    console.log(chalk.blue(`Restoring ${targetName} from backup...`));
-    const restored = restoreFile(targetFile);
-
-    if (restored) {
-        console.log(chalk.green(`\u2713 ${targetName} restored from backup`));
-    } else {
-        console.log(chalk.yellow('No backup file found.'));
-        console.log(chalk.gray(`Expected backup at: ${targetFile}.bak`));
-    }
-}
-
 /**
  * Prompt user to select a project.
  */
@@ -316,7 +234,7 @@ async function selectProject() {
         console.log();
         console.log(chalk.gray('To get started:'));
         console.log(chalk.white(`  1. Link a Vue project: ${chalk.cyan('magentrix iris-link')}`));
-        console.log(chalk.white(`  2. Or specify path: ${chalk.cyan('magentrix iris-dev --path /path/to/vue-project')}`));
+        console.log(chalk.white(`  2. Or specify path: ${chalk.cyan('magentrix run-dev --path /path/to/vue-project')}`));
         console.log();
     }
 

package/actions/setup.js

@@ -3,8 +3,9 @@ import { ensureInstanceUrl } from "../utils/cli/helpers/ensureInstanceUrl.js";
 import Config from "../utils/config.js";
 import { getAccessToken, tryAuthenticate } from "../utils/magentrix/api/auth.js";
 import { ensureVSCodeFileAssociation } from "../utils/preferences.js";
-import { EXPORT_ROOT, HASHED_CWD } from "../vars/global.js";
+import { CWD, EXPORT_ROOT, HASHED_CWD } from "../vars/global.js";
 import { select } from "@inquirer/prompts";
+import { registerWorkspace } from "../utils/workspaces.js";
 
 const config = new Config();
 
@@ -116,6 +117,9 @@ export const setup = async (cliOptions = {}) => {
         { global: true, pathHash: HASHED_CWD }
     );
 
+    // Register this workspace in the global registry
+    registerWorkspace(CWD, instanceUrl);
+
     // Set up the editor
     await ensureVSCodeFileAssociation('./');
 

package/bin/magentrix.js

@@ -13,11 +13,15 @@ import { create } from '../actions/create.js';
 import { autoPublish } from '../actions/autopublish.js';
 import { status } from '../actions/status.js';
 import { cacheDir, recacheFileIdIndex } from '../utils/cacher.js';
-import { EXPORT_ROOT } from '../vars/global.js';
+import { CWD, EXPORT_ROOT, HASHED_CWD } from '../vars/global.js';
 import { publish } from '../actions/publish.js';
 import { update } from '../actions/update.js';
 import { configWizard } from '../actions/config.js';
 import { irisLink, irisDev, irisDelete, irisRecover, vueBuildStage } from '../actions/iris/index.js';
+import Config from '../utils/config.js';
+import { registerWorkspace, getRegisteredWorkspaces } from '../utils/workspaces.js';
+
+const config = new Config();
 
 // ── Vue Project Detection ────────────────────────────────
 /**
@@ -44,8 +48,25 @@ function requireMagentrixWorkspace(fn) {
             console.error(chalk.gray('This command requires a Magentrix workspace with global API key and instance URL.\n'));
             console.error(chalk.cyan('Available commands in Vue projects:'));
             console.error(chalk.gray('  • magentrix iris-link'));
-            console.error(chalk.gray('  • magentrix iris-dev'));
-            console.error(chalk.gray('  • magentrix vue-build-stage\n'));
+            console.error(chalk.gray('  • magentrix vue-build-stage'));
+            console.error(chalk.gray('  • magentrix run-dev'));
+            console.error(chalk.gray('  • magentrix update\n'));
+            process.exit(1);
+        }
+        // Execute the command
+        await fn(...args);
+    };
+}
+
+/**
+ * Block commands that should not run in Vue projects (but don't require a workspace)
+ */
+function blockInVueProject(fn) {
+    return async (...args) => {
+        if (isInVueProject()) {
+            console.error(`\n${chalk.bgRed.white.bold(' ERROR ')} ${chalk.redBright('This command cannot be run in a Vue project')}\n`);
+            console.error(chalk.yellow('It looks like you\'re in a Vue project directory.'));
+            console.error(chalk.gray('Please run this command from a Magentrix workspace or an empty directory.\n'));
             process.exit(1);
         }
         // Execute the command
@@ -54,7 +75,33 @@ function requireMagentrixWorkspace(fn) {
 }
 
 // ── Middleware ────────────────────────────────
+
+/**
+ * Auto-register existing workspaces for backwards compatibility.
+ * If the current directory has credentials configured but isn't in the
+ * global workspace registry, register it automatically.
+ */
+function ensureWorkspaceRegistered() {
+    // Check if current directory has credentials configured
+    const instanceUrl = config.read('instanceUrl', { global: true, pathHash: HASHED_CWD });
+    const apiKey = config.read('apiKey', { global: true, pathHash: HASHED_CWD });
+
+    if (!instanceUrl || !apiKey) {
+        return; // Not a configured workspace
+    }
+
+    // Check if already registered
+    const workspaces = getRegisteredWorkspaces();
+    const alreadyRegistered = workspaces.some(w => w.path === CWD);
+
+    if (!alreadyRegistered) {
+        // Auto-register for backwards compatibility
+        registerWorkspace(CWD, instanceUrl);
+    }
+}
+
 async function preMiddleware() {
+    ensureWorkspaceRegistered();
     await recacheFileIdIndex(EXPORT_ROOT);
     await cacheDir(EXPORT_ROOT);
 }
@@ -80,7 +127,7 @@ program
     .description('Manage Magentrix assets and automation')
     .version(VERSION)
     .configureHelp({
-        formatHelp: (cmd, helper) => {
+        formatHelp: (_cmd, _helper) => {
             const divider = chalk.gray('━'.repeat(60));
             const titleBar = chalk.bold.bgBlue.white(' Magentrix CLI ');
             const version = chalk.dim(`v${VERSION}`);
@@ -105,7 +152,7 @@ program
                 { name: 'update', desc: 'Update MagentrixCLI to the latest version', icon: '⬆️  ' },
                 { name: 'iris-link', desc: 'Link a Vue project to the CLI', icon: '🔗 ' },
                 { name: 'vue-build-stage', desc: 'Build Vue project and stage for publish', icon: '🏗️  ' },
-                { name: 'iris-dev', desc: 'Start Vue dev server with platform assets', icon: '🌐 ' },
+                { name: 'run-dev', desc: 'Start Vue dev server with platform assets', icon: '🌐 ' },
                 { name: 'iris-delete', desc: 'Delete an Iris app with backup', icon: '🗑️  ' },
                 { name: 'iris-recover', desc: 'Recover a deleted Iris app from backup', icon: '♻️  ' }
             ];
@@ -137,7 +184,7 @@ program
 // ── Error Handlers ───────────────────────────
 program.showHelpAfterError(false);
 program.configureOutput({
-    outputError: (str, write) => {
+    outputError: (str, _write) => {
         // Custom error message for unknown options
         if (str.includes('unknown option')) {
             const match = str.match(/'([^']+)'/);
@@ -167,7 +214,7 @@ program
     .description('Configure your Magentrix API key')
     .option('--api-key <apiKey>', 'Magentrix API key')
     .option('--instance-url <instanceUrl>', 'Magentrix instance URL (e.g., https://example.magentrixcloud.com)')
-    .action(withWorkspaceCheck(setup));
+    .action(blockInVueProject(setup));
 program.command('pull').description('Pull files from the remote server').action(withWorkspaceCheck(pull));
 const createCommand = program
     .command('create')
@@ -228,7 +275,7 @@ program.command('status').description('Show file conflicts').action(withWorkspac
 program.command('autopublish').description('Watch & sync changes in real time').action(withWorkspaceCheck(autoPublish));
 // Publish does its own comprehensive file scanning, so skip the pre-cache middleware
 program.command('publish').description('Publish pending changes to the remote server').action(withWorkspaceCheck(publish));
-program.command('update').description('Update MagentrixCLI to the latest version').action(requireMagentrixWorkspace(update));
+program.command('update').description('Update MagentrixCLI to the latest version').action(update);
 
 // Config command - interactive wizard
 program
@@ -251,14 +298,14 @@ program
     .description('Build a Vue project and stage it for publishing')
     .option('--path <path>', 'Path to the Vue project')
     .option('--skip-build', 'Skip build step and use existing dist/')
+    .option('--workspace <workspace>', 'Path to Magentrix workspace to stage into')
     .action(vueBuildStage);
 
 program
-    .command('iris-dev')
+    .command('run-dev')
     .description('Start Vue dev server with platform assets injected')
     .option('--path <path>', 'Path to the Vue project')
     .option('--no-inject', 'Skip asset injection')
-    .option('--restore', 'Restore config.ts from backup')
     .action(irisDev);
 
 program
@@ -282,8 +329,9 @@ program.argument('[command]', 'command to run').action((cmd) => {
             console.error(chalk.gray('This command requires a Magentrix workspace with global API key and instance URL.\n'));
             console.error(chalk.cyan('Available commands in Vue projects:'));
             console.error(chalk.gray('  • magentrix iris-link'));
-            console.error(chalk.gray('  • magentrix iris-dev'));
-            console.error(chalk.gray('  • magentrix vue-build-stage\n'));
+            console.error(chalk.gray('  • magentrix vue-build-stage'));
+            console.error(chalk.gray('  • magentrix run-dev'));
+            console.error(chalk.gray('  • magentrix update\n'));
             process.exit(1);
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magentrix-corp/magentrix-cli",
-  "version": "1.3.3",
+  "version": "1.3.5",
   "description": "CLI tool for synchronizing local files with Magentrix cloud platform",
   "main": "index.js",
   "type": "module",

package/utils/iris/builder.js

@@ -47,11 +47,12 @@ export async function buildVueProject(projectPath, options = {}) {
         const errorOutput = [];
 
         // Determine npm command based on platform
-        const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+        const isWindows = process.platform === 'win32';
+        const npmCmd = isWindows ? 'npm.cmd' : 'npm';
 
         const child = spawn(npmCmd, ['run', 'build'], {
             cwd: resolvedPath,
-            shell: false,
+            shell: isWindows,  // Windows requires shell: true for .cmd files
             env: { ...process.env, FORCE_COLOR: '1' }
         });
 
@@ -127,11 +128,11 @@ export async function buildVueProject(projectPath, options = {}) {
 }
 
 /**
- * Stage build output to the CLI project's iris-apps directory.
+ * Stage build output to a Magentrix workspace's iris-apps directory.
  *
  * @param {string} distPath - Path to the build output (dist directory)
  * @param {string} slug - The app slug (folder name)
- * @param {string} cliProjectPath - Path to the CLI project root (defaults to CWD)
+ * @param {string} workspacePath - Path to the Magentrix workspace (defaults to CWD)
  * @returns {{
  *   success: boolean,
  *   stagedPath: string | null,
@@ -139,9 +140,9 @@ export async function buildVueProject(projectPath, options = {}) {
  *   fileCount: number
  * }}
  */
-export function stageToCliProject(distPath, slug, cliProjectPath = process.cwd()) {
+export function stageToWorkspace(distPath, slug, workspacePath = process.cwd()) {
     const resolvedDistPath = resolve(distPath);
-    const irisAppsDir = join(cliProjectPath, EXPORT_ROOT, IRIS_APPS_DIR);
+    const irisAppsDir = join(workspacePath, EXPORT_ROOT, IRIS_APPS_DIR);
     const targetDir = join(irisAppsDir, slug);
 
     // Validate dist path exists

package/utils/workspaces.js

@@ -0,0 +1,108 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import Config from './config.js';
+
+const config = new Config();
+
+/**
+ * Register a workspace in the global registry.
+ * This stores the workspace path so it can be discovered later.
+ *
+ * @param {string} workspacePath - Full path to the workspace
+ * @param {string} instanceUrl - The Magentrix instance URL for this workspace
+ */
+export function registerWorkspace(workspacePath, instanceUrl) {
+    const workspaces = config.read('workspaces', { global: true }) || [];
+
+    // Check if already registered
+    const existingIndex = workspaces.findIndex(w => w.path === workspacePath);
+
+    if (existingIndex >= 0) {
+        // Update existing entry
+        workspaces[existingIndex] = {
+            path: workspacePath,
+            instanceUrl,
+            lastUsed: new Date().toISOString()
+        };
+    } else {
+        // Add new entry
+        workspaces.push({
+            path: workspacePath,
+            instanceUrl,
+            lastUsed: new Date().toISOString()
+        });
+    }
+
+    config.save('workspaces', workspaces, { global: true });
+}
+
+/**
+ * Get all registered workspaces from the global registry.
+ * Validates that each workspace still exists on disk.
+ *
+ * @returns {Array<{path: string, instanceUrl: string, lastUsed: string, valid: boolean}>}
+ */
+export function getRegisteredWorkspaces() {
+    const workspaces = config.read('workspaces', { global: true }) || [];
+
+    return workspaces.map(workspace => {
+        // Check if the workspace still exists and is valid
+        const magentrixFolder = join(workspace.path, '.magentrix');
+        const srcFolder = join(workspace.path, 'src');
+
+        const valid = existsSync(magentrixFolder) && existsSync(srcFolder);
+
+        return {
+            ...workspace,
+            valid
+        };
+    });
+}
+
+/**
+ * Get all valid registered workspaces (those that still exist on disk).
+ *
+ * @returns {Array<{path: string, instanceUrl: string, lastUsed: string, valid: boolean}>}
+ */
+export function getValidWorkspaces() {
+    return getRegisteredWorkspaces().filter(w => w.valid);
+}
+
+/**
+ * Remove a workspace from the global registry.
+ *
+ * @param {string} workspacePath - Path to the workspace to remove
+ * @returns {boolean} True if removed, false if not found
+ */
+export function unregisterWorkspace(workspacePath) {
+    const workspaces = config.read('workspaces', { global: true }) || [];
+    const initialLength = workspaces.length;
+
+    const filtered = workspaces.filter(w => w.path !== workspacePath);
+
+    if (filtered.length < initialLength) {
+        config.save('workspaces', filtered, { global: true });
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * Clean up invalid workspaces (those that no longer exist on disk).
+ *
+ * @returns {number} Number of workspaces removed
+ */
+export function cleanupInvalidWorkspaces() {
+    const workspaces = getRegisteredWorkspaces();
+    const validWorkspaces = workspaces.filter(w => w.valid);
+    const removedCount = workspaces.length - validWorkspaces.length;
+
+    if (removedCount > 0) {
+        // Remove the 'valid' property before saving
+        const toSave = validWorkspaces.map(({ valid, ...rest }) => rest);
+        config.save('workspaces', toSave, { global: true });
+    }
+
+    return removedCount;
+}