orionplace-nuxt 0.1.1 → 0.1.2

package/README.md

@@ -66,8 +66,8 @@ npx orionplace-nuxt set backend your-project.orionplace.app
 npx orionplace-nuxt add frontend shop.example.com
 npx orionplace-nuxt add frontend www.shop.example.com
 npx orionplace-nuxt remove frontend www.shop.example.com
-npx orionplace-nuxt set frontend shop.example.com
-npx orionplace-nuxt --help
+npx orionplace-nuxt set mimic shop.example.com
+npx orionplace-nuxt help
 ```
 
 Either domain command can run first. Both settings are needed for a usable mapping.
@@ -77,6 +77,8 @@ After setup, these npm script aliases are also available:
 npm run orionplace:backend -- your-project.orionplace.app
 npm run orionplace:add-frontend -- shop.example.com
 npm run orionplace:remove-frontend -- www.shop.example.com
+npm run orionplace:mimic -- shop.example.com
+npm run orionplace:help
 ```
 
 `npm set` belongs to npm's own configuration system; use the commands above.
@@ -109,9 +111,14 @@ Each frontend gets its own `sitemaps/<domain>.cfg`. `add frontend` preserves oth
 domains and can be repeated safely. `set backend` updates every CLI-managed mapping
 to the new personal API; it refuses to overwrite a manually edited mapping.
 
-The first added frontend becomes `MIMIC_FRONT_DOMAIN` in `.env`. Further additions
-preserve that local development choice. `set frontend <domain>` adds the domain
-if needed and selects it for MIMIC; it does not remove other domains.
+A new project starts with `MIMIC_FRONT_DOMAIN=""` in `.env`. Setting a backend
+alone leaves it empty. The first added frontend becomes MIMIC; further additions
+preserve that choice. `set mimic <domain>` selects an already-added frontend and
+updates MIMIC without changing any domain mappings. Unknown domains are rejected;
+add them with `add frontend` first.
+
+`help`, `--help`, and `-h` display commands without writing files. The legacy
+`set frontend <domain>` shortcut remains supported: it adds and selects a domain.
 
 `remove frontend <domain>` removes that domain from the list and deletes only its
 unchanged generated `.cfg`. Removing the MIMIC domain selects the first remaining

package/bin/orionplace-nuxt.mjs

@@ -6,22 +6,26 @@ import { createInterface } from 'node:readline/promises';
 
 const help = `Orionplace Nuxt setup
 
+  npx orionplace-nuxt help
   npx orionplace-nuxt init [directory]
   npx orionplace-nuxt set backend <personal-backend.orionplace.app>
   npx orionplace-nuxt add frontend <shop.example.com>
   npx orionplace-nuxt remove frontend <shop.example.com>
+  npx orionplace-nuxt set mimic <existing-frontend.example.com>
   npx orionplace-nuxt set frontend <shop.example.com>
 
 Options: --cwd <directory>  --dry-run  --help  --version
 
 Set backend or add frontend also initializes the integration; either can come first.
-Add frontend keeps other domains and the current MIMIC domain. Set frontend selects MIMIC.
+MIMIC starts empty. The first added frontend sets it; later additions preserve it.
+Set mimic selects an existing frontend without changing any domain mappings.
+Set frontend is the legacy shortcut to add and select a frontend.
 Set backend updates every managed frontend mapping. Remove frontend deletes only that mapping.
 After creating a new project, run npm install and npm run dev in that directory.
 Documentation and editable server source are generated in orionplace/.`;
 try {
   const argv = process.argv.slice(2);
-  if (!argv.length || argv.includes('--help') || argv.includes('-h')) {
+  if (!argv.length || argv[0] === 'help' || argv.includes('--help') || argv.includes('-h')) {
     console.log(help);
   } else if (argv.includes('--version')) {
     console.log(JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf8')).version);
@@ -41,12 +45,12 @@ try {
     let result;
     if (command === 'init' && positional.length <= 2) {
       result = await setupProject({ cwd: target ? resolve(cwd, target) : cwd, dryRun });
-    } else if (((command === 'set' && ['backend', 'frontend'].includes(target)) ||
+    } else if (((command === 'set' && ['backend', 'frontend', 'mimic'].includes(target)) ||
         (['add', 'remove'].includes(command) && target === 'frontend')) && positional.length <= 3) {
       let value = positional[2];
       if (!value && process.stdin.isTTY) {
         const prompt = createInterface({ input: process.stdin, output: process.stdout });
-        try { value = await prompt.question(`${target === 'backend' ? 'Personal backend API' : 'Public frontend domain'}: `); }
+        try { value = await prompt.question(`${target === 'backend' ? 'Personal backend API' : target === 'mimic' ? 'Existing frontend to use for MIMIC' : 'Public frontend domain'}: `); }
         finally { prompt.close(); }
       }
       if (!value) throw new Error(`Provide the ${target} domain. See --help.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orionplace-nuxt",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Nuxt integration and setup CLI for your Orionplace personal marketplace backend.",
   "type": "module",
   "license": "MIT",

package/src/module.mjs

@@ -29,6 +29,8 @@ export default defineNuxtModule({
     // Do not inherit page caching for authenticated API requests.
     routes['/api/**'] = { ...routes['/api/**'], cache: false, swr: false,
       headers: { ...routes['/api/**']?.headers, 'cache-control': 'no-store' } };
+    // MIMIC defaults to empty. The CLI sets .env on the first "add frontend"
+    // or an explicit "set mimic"; never infer it from the domain-file directory.
     // Values stay private to the server. MIMIC_FRONT_DOMAIN is also read at runtime.
     nuxt.options.runtimeConfig.mimicFrontDomain ??= '';
     nuxt.options.runtimeConfig.mimicFrontDomain = process.env.MIMIC_FRONT_DOMAIN

package/src/project-readme.mjs

@@ -10,7 +10,7 @@ You can change that backend domain in your account, then update this project.
 ## Current setup
 
 - Frontend domains: ${settings.frontends?.length ? settings.frontends.map(domain => '\`' + domain + '\`').join(', ') : 'not configured yet'}
-- Local MIMIC domain: \`${settings.frontend || 'not configured yet'}\`
+- Local MIMIC domain: \`${settings.frontend || 'empty'}\`
 - Personal API: \`${settings.backend || 'not configured yet'}\`
 
 Set or change these values from the project root:
@@ -26,9 +26,19 @@ Set the backend or add a frontend first; either order works. Each frontend has i
 own \`sitemaps/<domain>.cfg\` mapping to your personal API. Adding a domain again
 is safe. Changing the backend updates every CLI-managed frontend mapping.
 
-The first added frontend becomes \`MIMIC_FRONT_DOMAIN\` in \`.env\`. Adding more
-domains preserves that choice. Use \`npx orionplace-nuxt set frontend <domain>\`
-to add and select a different local domain.
+MIMIC is empty in a new project: \`MIMIC_FRONT_DOMAIN=""\`. Setting the backend
+alone leaves it empty. The first added frontend sets MIMIC; adding more domains
+preserves that choice.
+
+Use \`npx orionplace-nuxt set mimic <domain>\` to select an already-added frontend
+for localhost. It changes MIMIC without editing domain mappings. Add an unknown
+domain with \`add frontend\` first. The legacy \`set frontend\` shortcut still
+adds and selects a frontend.
+
+\`\`\`bash
+npx orionplace-nuxt help
+npx orionplace-nuxt set mimic ${frontend}
+\`\`\`
 
 Removing a frontend deletes only its unchanged generated \`.cfg\` file. If it was
 the selected MIMIC domain, the first remaining domain takes its place. Removing

package/src/setup.mjs

@@ -58,11 +58,11 @@ function updateEnvironment(source, domain) {
 
 export async function setupProject({ cwd = process.cwd(), action = 'set', field, value, dryRun = false } = {}) {
   if (!['set', 'add', 'remove'].includes(action) || (action !== 'set' && field !== 'frontend')) {
-    throw new Error('Use set backend, add frontend, remove frontend, or set frontend.');
+    throw new Error('Use set backend, add frontend, remove frontend, set mimic, or set frontend.');
   }
   const root = resolve(cwd);
-  const setting = field === 'backend' ? backendUrl(value) : field === 'frontend' ? frontendDomain(value) : null;
-  if (field && !setting) throw new Error('Choose backend or frontend.');
+  const setting = field === 'backend' ? backendUrl(value) : ['frontend', 'mimic'].includes(field) ? frontendDomain(value) : null;
+  if (field && !setting) throw new Error('Choose backend, frontend, or mimic.');
   const names = ['package.json', 'nuxt.config.ts', 'nuxt.config.js', 'nuxt.config.mjs', 'orionplace/settings.json', 'orionplace/.generated.json', '.env', '.gitignore'];
   const current = {};
   for (const name of names) current[name] = await read(await safePath(root, name));
@@ -98,6 +98,12 @@ export async function setupProject({ cwd = process.cwd(), action = 'set', field,
   settings.frontends = [...new Set(frontends.map(frontendDomain))];
   if (settings.frontend && !settings.frontends.includes(settings.frontend)) settings.frontends.unshift(settings.frontend);
   if (field === 'backend') settings.backend = setting;
+  if (field === 'mimic') {
+    if (!settings.frontends.includes(setting)) {
+      throw new Error(`Add this frontend before selecting it for MIMIC: ${setting}`);
+    }
+    settings.frontend = setting;
+  }
   if (field === 'frontend') {
     if (action === 'remove') {
       if (!settings.frontends.includes(setting)) throw new Error(`Frontend is not managed by this project: ${setting}`);
@@ -143,6 +149,8 @@ export async function setupProject({ cwd = process.cwd(), action = 'set', field,
   pkg.scripts['orionplace:frontend'] ||= 'orionplace-nuxt set frontend';
   pkg.scripts['orionplace:add-frontend'] ||= 'orionplace-nuxt add frontend';
   pkg.scripts['orionplace:remove-frontend'] ||= 'orionplace-nuxt remove frontend';
+  pkg.scripts['orionplace:mimic'] ||= 'orionplace-nuxt set mimic';
+  pkg.scripts['orionplace:help'] ||= 'orionplace-nuxt help';
   pkg.dependencies ||= {};
   pkg.dependencies['orionplace-nuxt'] ||= dependencies['orionplace-nuxt'] || `^${metadata.version}`;
   if (isNewNuxt) {
@@ -158,9 +166,13 @@ export async function setupProject({ cwd = process.cwd(), action = 'set', field,
   if (isNewNuxt && !(await read(await safePath(root, 'app/app.vue')))) {
     await plan('app/app.vue', '<template>\n  <main>\n    <h1>Your marketplace</h1>\n    <p>Domain setup and API instructions are in orionplace/README.md.</p>\n  </main>\n</template>\n', { managed: true });
   }
-  if (settings.frontend || oldFrontend) await plan('.env', updateEnvironment(current['.env'], settings.frontend || ''));
+  // A new project starts explicitly empty; keep a pre-existing manual setting on init.
+  const hasMimicSetting = /^\s*(?:export\s+)?MIMIC_FRONT_DOMAIN\s*=/m.test(current['.env'] || '');
+  if (settings.frontend || oldFrontend || !hasMimicSetting) {
+    await plan('.env', updateEnvironment(current['.env'], settings.frontend || ''));
+  }
   if (settings.backend) {
-    const mappings = action === 'remove' ? []
+    const mappings = action === 'remove' || field === 'mimic' ? []
       : field === 'frontend' ? [setting] : settings.frontends;
     for (const domain of mappings) {
       await plan(`sitemaps/${domain}.cfg`, settings.backend + '\n', { managed: true });