orionplace-nuxt 0.2.1 → 0.4.0

package/README.md

@@ -9,6 +9,8 @@ setup CLI and the full storefront source, so every page and component in your
 project is yours to change.
 
 - **Setup CLI:** `init`, `set backend`, `add frontend`, `set mimic` and `update`.
+- **Server install:** `install` builds the storefront on your Linux server and
+  runs it as a system service behind nginx with HTTPS.
 - **API gateway:** the browser calls `/api/...` on your own domain; the server
   forwards it to your marketplace backend with cookies bound to the storefront.
 - **Typed store:** one Application Load request fills it before the first render.
@@ -19,8 +21,8 @@ project is yours to change.
 
 **Contents:** [Quick start](#quick-start-from-zero) ·
 [Existing project](#existing-nuxt-4-project) · [Components](#components) ·
-[Commands](#commands) · [Android app](#android-app) ·
-[Update](#update-an-existing-project)
+[Commands](#commands) · [Server install](#install-on-your-server) ·
+[Android app](#android-app) · [Update](#update-an-existing-project)
 
 Requires Node.js 22.12+ and a Node server deployment. Static-only and edge
 hosting are not supported by this filesystem-based integration.
@@ -316,6 +318,9 @@ 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 mimic shop.example.com
+sudo npx orionplace-nuxt install
+npx orionplace-nuxt status
+sudo npx orionplace-nuxt restart
 npx orionplace-nuxt help
 ```
 
@@ -332,8 +337,63 @@ npm run orionplace:update
 ```
 
 `npm set` belongs to npm's own configuration system; use the commands above.
-These commands configure local integration files. They do not provision a backend,
-change your account, create DNS records, configure TLS, or deploy a VPS.
+The setup commands configure local integration files. They do not provision a
+backend, change your account or create DNS records. `install` deploys the
+storefront on your server; see [Install on your server](#install-on-your-server).
+
+## Install on your server
+
+Prepare a Linux server once with the OrionMarketplace server script: it installs
+Node.js, nginx and certbot and adds the `orionplace` command
+([server guide](https://orionmarket.place/en/sandbox/install)).
+
+```bash
+curl -fsSLo orionplace.sh https://orionmarket.place/downloads/orionplace.sh
+sudo sh orionplace.sh setup
+```
+
+Then create the storefront in `/srv/orionplace` and install it:
+
+```bash
+cd /srv/orionplace
+sudo npx --yes orionplace-nuxt init shop
+cd shop
+sudo npm install
+sudo npx orionplace-nuxt install
+```
+
+`install` asks for your backend and storefront domain when they are missing,
+builds the project, runs it as the system service `orionplace-shop` on a free
+local port and connects each storefront domain with nginx and a Let's Encrypt
+certificate. Run it again after code or package updates; the service keeps its
+port. Options: `--name <service>`, `--port <port>`, `--user <user>`,
+`--no-build` (install the build already in the folder), `--no-domains`, `--yes`,
+`--dry-run`. Full guide:
+[Install a storefront](https://orionmarket.place/en/sandbox/install/storefront).
+
+### Manage the service
+
+Run these in the project folder, or name the service from anywhere with
+`--name shop`:
+
+```bash
+npx orionplace-nuxt status            # running?, autostart, port, home page answer, domains
+sudo npx orionplace-nuxt start
+sudo npx orionplace-nuxt stop
+sudo npx orionplace-nuxt restart      # waits until the home page answers again
+sudo npx orionplace-nuxt logs 200     # last log lines; --follow keeps reading
+npx orionplace-nuxt list              # every storefront service on this server
+sudo npx orionplace-nuxt uninstall    # stop and remove the service (alias: cleanup)
+```
+
+`start` and `restart` wait up to 90 seconds for the home page and print the
+last log lines when it does not answer. `status` ends with code 3 when the
+storefront is stopped or does not answer, so scripts and monitors can use it.
+`uninstall` (or `cleanup`) stops the service, takes it out of autostart and
+deletes its unit file and registration; the project folder and its build stay.
+With the `orionplace` server tool it runs `orionplace app remove`, which also
+turns the storefront's domains into a placeholder page. `--dry-run` shows what it
+would remove; `--yes` skips the question.
 
 ## Generated files
 
@@ -397,6 +457,20 @@ authorization and cookies are forwarded. Backend statuses are retained and cooki
 Domain attributes are removed to bind cookies to the storefront. Gateway responses
 use `Cache-Control: no-store`. Network failures return `502`.
 
+A changing request (POST, PUT, PATCH, DELETE) from another site is rejected with
+`403`. A request from the page's own host or the storefront domain passes, and the
+backend receives it with the storefront domain's origin
+(`https://shop.example.com`), the one it accepts forms from. So a host that shows
+the storefront through `X-Front-Domain`, such as a preview host or a local port,
+can sign in too.
+
+A changing request (POST, PUT, PATCH, DELETE) from another site is rejected with
+`403`. A request from the page's own host or the storefront domain passes, and the
+backend receives it with the storefront domain's origin
+(`https://shop.example.com`), the one it accepts forms from. So a host that shows
+the storefront through `X-Front-Domain`, such as a preview host or a local port,
+can sign in too.
+
 Browser requests use `/api/...`. For SSR, use Nuxt's `useRequestFetch()` to pass
 the current request's domain and authentication to the same gateway. See the
 project README for examples and cookie handling.

package/bin/orionplace-nuxt.mjs

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import { setupProject } from '../src/setup.mjs';
 import { updateProject } from '../src/update.mjs';
+import { installService } from '../src/install.mjs';
+import { SERVICE_ACTIONS, SERVICE_ALIASES, controlService, findApp, printService } from '../src/service.mjs';
 import { readFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { createInterface } from 'node:readline/promises';
@@ -29,8 +31,27 @@ Commands for an existing project (run from its root):
   npx orionplace-nuxt set mimic <existing-frontend.example.com>
   npx orionplace-nuxt set frontend <shop.example.com>
 
+On your Linux server (run from the project root):
+  sudo npx orionplace-nuxt install
+  Builds the storefront, installs it as a system service (systemd or OpenRC)
+  and, when the orionplace server tool is set up, connects its domains with
+  nginx and HTTPS. Run it again after changes or an update to rebuild and restart.
+  Server tool: https://orionmarket.place/downloads/orionplace.sh
+
+Manage the installed service (from the project root, or name it with --name):
+  npx orionplace-nuxt status              service, autostart, port and home page answer
+  sudo npx orionplace-nuxt start
+  sudo npx orionplace-nuxt stop
+  sudo npx orionplace-nuxt restart        restart and wait until the home page answers
+  sudo npx orionplace-nuxt logs [lines]   last log lines (100); --follow keeps reading
+  npx orionplace-nuxt list                every storefront service on this server
+  sudo npx orionplace-nuxt uninstall      stop the service and remove it (alias: cleanup);
+                                       the project folder stays
+
 Options: --cwd <directory>  --dry-run  --help  --version
 Update option: --local (apply this CLI version instead of fetching the latest release)
+Install options: --name <service>  --port <port>  --user <user>  --no-build  --no-domains  --yes
+Service options: --name <service>  --follow (logs)  --dry-run --yes (uninstall)
 
 Update downloads the latest release, refreshes unedited source, and installs dependencies.
 It preserves edited source, domain mappings and MIMIC. --dry-run leaves project files unchanged.
@@ -52,19 +73,64 @@ try {
     let cwd          = process.cwd();
     let dryRun       = false;
     let local        = false;
+    let follow       = false;
+    const install    = { domains: true, build: true, yes: false };
     for (let index = 0; index < argv.length; index++) {
       if (argv[index] === '--dry-run') dryRun = true;
       else if (argv[index] === '--local') local = true;
-      else if (argv[index] === '--cwd') {
+      else if (argv[index] === '--no-domains') install.domains = false;
+      else if (argv[index] === '--no-build') install.build = false;
+      else if (argv[index] === '--follow' || argv[index] === '-f') follow = true;
+      else if (argv[index] === '--yes' || argv[index] === '-y') install.yes = true;
+      else if (['--name', '--port', '--user'].includes(argv[index])) {
+        if (!argv[index + 1]) throw new Error(`${argv[index]} needs a value`);
+        install[argv[index].slice(2)] = argv[++index];
+      } else if (argv[index] === '--cwd') {
         if (!argv[index + 1]) throw new Error('--cwd needs a directory');
         cwd = resolve(argv[++index]);
       } else if (argv[index].startsWith('--')) throw new Error(`Unknown option: ${argv[index]}`);
       else positional.push(argv[index]);
     }
-    const [command, target] = positional;
+    const [given, target] = positional;
+    const command    = SERVICE_ALIASES[given] || given;
     if (local && command !== 'update') throw new Error('--local is only supported by update.');
+    const service    = SERVICE_ACTIONS.includes(command);
+    if (command !== 'install' && (install.port || install.user || !install.domains || !install.build || (install.yes && command !== 'uninstall') || (install.name && !service))) {
+      throw new Error('--port, --user, --no-build, --no-domains and --yes are install options (--yes also for uninstall); --name is for install and the service commands.');
+    }
+    if (follow && command !== 'logs') throw new Error('--follow is a logs option.');
+    if (dryRun && service && command !== 'uninstall') throw new Error('--dry-run is only for uninstall among the service commands; status shows the state without changes.');
     let result;
-    if (command === 'init' && positional.length <= 2) {
+    if (command === 'install' && positional.length === 1) {
+      const done = await installService({ cwd, dryRun, ...install });
+      if (done.dryRun) {
+        console.log(`Planned service orionplace-${done.name} on 127.0.0.1:${done.port} as ${done.user}`);
+        console.log(`Domains: ${done.frontends.join(', ') || 'none yet'} -> ${done.backend || 'no backend yet'}`);
+        console.log(`\n${done.unitPath}:\n${done.unit}`);
+      } else {
+        console.log(`\nInstalled orionplace-${done.name} (port ${done.port}, user ${done.user}).`);
+        for (const domain of done.frontends) {
+          if (!install.domains) console.log(`  - ${domain}: not connected (--no-domains)`);
+          else if (!done.connected) console.log(`  - ${domain}: not connected to nginx (see above)`);
+          else if (done.failed.includes(domain)) console.log(`  ✗ ${domain}: not connected (see above)`);
+          else console.log(`  ✓ https://${domain}`);
+        }
+        if (done.failed.length) console.log('Fix the problems above, then run: sudo orionplace domain add <domain>');
+        console.log(`Manage it from this folder: npx orionplace-nuxt status | sudo npx orionplace-nuxt restart | sudo npx orionplace-nuxt logs`);
+        console.log('After code changes or npx orionplace-nuxt update, run sudo npx orionplace-nuxt install again.');
+      }
+    } else if (service && positional.length <= (command === 'logs' ? 2 : 1)) {
+      if (command === 'uninstall' && !dryRun && !install.yes && process.stdin.isTTY) {
+        const app    = await findApp({ cwd, name: install.name });
+        const prompt = createInterface({ input: process.stdin, output: process.stdout });
+        let answer;
+        try { answer = await prompt.question(`Stop and remove the service orionplace-${app.NAME}? The project stays in ${app.DIR}. [y/N] `); }
+        finally { prompt.close(); }
+        if (!/^y(es)?$/i.test(answer.trim())) { console.log('Nothing changed.'); process.exit(0); }
+      }
+      const done       = await controlService({ action: command, cwd, name: install.name, lines: positional[1] ?? 100, follow, dryRun });
+      process.exitCode = printService(done);
+    } else if (command === 'init' && positional.length <= 2) {
       result = await setupProject({ cwd: target ? resolve(cwd, target) : cwd, dryRun });
     } else if (command === 'update' && positional.length === 1) {
       result = await updateProject({ cwd, dryRun, local });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orionplace-nuxt",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "Nuxt 4 storefront for your Orionplace marketplace: setup CLI, server API gateway, typed store and ready-made catalog, cart, checkout and account components in English and Russian, plus an Android app build.",
   "type": "module",
   "license": "MIT",

package/runtime/marketplace.mjs

@@ -208,6 +208,18 @@ export async function forwardMarketplace(request, configuration = {}) {
     }
   }
   headers.set('X-Front-Domain', tenant.domain);
+  // The backend accepts forms from the storefront domain's own origin. A public
+  // host that shows this storefront (MIMIC, a preview host or a local port)
+  // passed the same-origin check above, so it is sent as that origin.
+  let ownOrigin         = false;
+  try {
+    ownOrigin = Boolean(origin) && originHosts.includes(new URL(origin).host);
+  } catch {
+    ownOrigin = false;
+  }
+  if (ownOrigin) {
+    headers.set('origin', `https://${tenant.domain}`);
+  }
   headers.set('Accept-Encoding', 'identity');
   const clientIp        =
     request.headers.get('x-init-ip') ||

package/src/install.mjs

@@ -0,0 +1,356 @@
+// Installs the built storefront as a system service on a Linux server and
+// connects its domains through the "orionplace" server tool
+// (https://orionmarket.place/downloads/orionplace.sh) when that tool is set up.
+import { spawn } from 'node:child_process';
+import { mkdir, readFile, readdir, rename, stat, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { request } from 'node:http';
+import { createServer } from 'node:net';
+import { basename, dirname, join, resolve } from 'node:path';
+import { createInterface } from 'node:readline/promises';
+import { setupProject } from './setup.mjs';
+
+export const framework = {
+  id:          'nuxt',
+  title:       'Nuxt',
+  dependency:  'nuxt',
+  output:      '.output/server/index.mjs',
+  start:       () => ['.output/server/index.mjs'],
+  environment: {},
+};
+
+export const defaultPaths = {
+  etc:     process.env.ORIONPLACE_ETC || '/etc/orionplace',
+  systemd: '/etc/systemd/system',
+  openrc:  '/etc/init.d',
+  logs:    '/var/log/orionplace',
+  srv:     '/srv/orionplace',
+  tool:    ['/usr/local/bin/orionplace', '/usr/bin/orionplace'],
+};
+
+const SERVICE_USER = 'orionplace';
+
+// run(command, args, { cwd, capture, env }) -> { code, output }
+export function runCommand(command, args, { cwd, capture = false, env = process.env } = {}) {
+  return new Promise((done, reject) => {
+    const child  = spawn(command, args, { cwd, env, stdio: capture ? ['ignore', 'pipe', 'pipe'] : 'inherit' });
+    let output   = '';
+    if (capture) {
+      child.stdout.on('data', chunk => { output += chunk; });
+      child.stderr.on('data', chunk => { output += chunk; });
+    }
+    child.once('error', reject);
+    child.once('exit', code => done({ code: code ?? 1, output }));
+  });
+}
+
+function parseConf(text) {
+  const values = {};
+  for (const line of text.split('\n')) {
+    const match = /^([A-Z_]+)=(.*)$/.exec(line);
+    if (match) values[match[1]] = match[2];
+  }
+  return values;
+}
+
+export async function readApps(paths = defaultPaths) {
+  const directory = join(paths.etc, 'apps');
+  let names       = [];
+  try { names = (await readdir(directory)).filter(name => name.endsWith('.conf')); }
+  catch (error) { if (error.code !== 'ENOENT') throw error; }
+  const apps      = [];
+  for (const name of names) apps.push(parseConf(await readFile(join(directory, name), 'utf8')));
+  return apps;
+}
+
+export function serviceName(value) {
+  const name = value.toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40);
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) throw new Error('Choose a service name with letters, digits and dashes: --name shop');
+  return name;
+}
+
+function portIsFree(port) {
+  return new Promise(done => {
+    const server = createServer();
+    server.once('error', () => done(false));
+    server.listen({ port, host: '127.0.0.1', exclusive: true }, () => server.close(() => done(true)));
+  });
+}
+
+export async function choosePort(apps, wanted, isFree = portIsFree) {
+  const taken = new Set(apps.map(app => Number(app.PORT)));
+  if (wanted) {
+    if (!Number.isInteger(wanted) || wanted < 1024 || wanted > 65535) throw new Error('Use a port between 1024 and 65535.');
+    return wanted;
+  }
+  for (let port = 3000; port < 4000; port++) {
+    if (!taken.has(port) && await isFree(port)) return port;
+  }
+  throw new Error('No free port between 3000 and 3999. Choose one with --port.');
+}
+
+async function passwdEntry(user) {
+  const text = await readFile('/etc/passwd', 'utf8');
+  for (const line of text.split('\n')) {
+    const [name, , uid, gid, , home] = line.split(':');
+    if (name === user) return { name, uid: Number(uid), gid: Number(gid), home };
+  }
+  return null;
+}
+
+async function userByUid(uid) {
+  const text = await readFile('/etc/passwd', 'utf8');
+  for (const line of text.split('\n')) {
+    const [name, , id, gid, , home] = line.split(':');
+    if (Number(id) === uid && name) return { name, uid, gid: Number(gid), home };
+  }
+  return null;
+}
+
+// Every parent folder must let the service user through.
+async function checkReachable(root, account) {
+  let cursor = dirname(root);
+  while (true) {
+    const info = await stat(cursor);
+    const open = info.uid === account.uid ? info.mode & 0o100 : info.gid === account.gid ? info.mode & 0o010 : info.mode & 0o001;
+    if (!open) {
+      throw new Error(`The folder ${cursor} is closed to the service user ${account.name}. Move the storefront to ${defaultPaths.srv}/ (for example ${defaultPaths.srv}/${basename(root)}) and run install there.`);
+    }
+    if (cursor === dirname(cursor)) return;
+    cursor = dirname(cursor);
+  }
+}
+
+async function writeAtomic(path, content, mode = 0o644) {
+  await mkdir(dirname(path), { recursive: true });
+  const temporary = `${path}.orionplace-${process.pid}.tmp`;
+  await writeFile(temporary, content, { mode });
+  await rename(temporary, path);
+}
+
+export function systemdUnit({ name, root, user, group, port, node, env }) {
+  const environment = Object.entries({ NODE_ENV: 'production', HOST: '127.0.0.1', PORT: String(port), SITEMAPS_DIR: join(root, 'sitemaps'), ...env })
+    .map(([key, value]) => `Environment=${key}=${value}`).join('\n');
+  const args        = [...(existsSync(join(root, '.env')) ? ['--env-file=.env'] : []), ...framework.start(port)];
+  return `# Installed by "orionplace-${framework.id} install". Run it again after changes;
+# manage with: orionplace app status|logs|restart ${name}
+[Unit]
+Description=OrionMarketplace storefront ${name} (${framework.title})
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=${user}
+Group=${group}
+WorkingDirectory=${root}
+${environment}
+ExecStart=${node} ${args.join(' ')}
+Restart=on-failure
+RestartSec=3
+LimitNOFILE=65535
+NoNewPrivileges=true
+PrivateTmp=true
+ProtectSystem=full
+
+[Install]
+WantedBy=multi-user.target
+`;
+}
+
+export function openrcScript({ name, root, user, group, port, node, env, logs }) {
+  const environment = Object.entries({ NODE_ENV: 'production', HOST: '127.0.0.1', PORT: String(port), SITEMAPS_DIR: join(root, 'sitemaps'), ...env })
+    .map(([key, value]) => `export ${key}="${value}"`).join('\n');
+  const args        = [...(existsSync(join(root, '.env')) ? ['--env-file=.env'] : []), ...framework.start(port)];
+  return `#!/sbin/openrc-run
+# Installed by "orionplace-${framework.id} install". Run it again after changes;
+# manage with: orionplace app status|logs|restart ${name}
+name="orionplace-${name}"
+description="OrionMarketplace storefront ${name} (${framework.title})"
+supervisor=supervise-daemon
+respawn_delay=3
+command="${node}"
+command_args="${args.join(' ')}"
+command_user="${user}:${group}"
+directory="${root}"
+output_log="${logs}/${name}.log"
+error_log="${logs}/${name}.log"
+${environment}
+
+depend() {
+  need net
+  after firewall
+}
+
+start_pre() {
+  checkpath --directory --owner ${user}:${group} --mode 0755 ${logs}
+}
+`;
+}
+
+async function prompt(question) {
+  const terminal = createInterface({ input: process.stdin, output: process.stdout });
+  try { return (await terminal.question(question)).trim(); }
+  finally { terminal.close(); }
+}
+
+function log(message) { console.log(message); }
+
+// /usr/local/bin/node from the server tool follows Node.js updates; the
+// versioned path of the running binary would not.
+function stableNode() {
+  return ['/usr/local/bin/node', '/usr/bin/node'].find(path => existsSync(path)) || process.execPath;
+}
+
+// Fills in the backend and first storefront domain when the project has none.
+async function ensureDomains(root, { yes }) {
+  const read     = async () => JSON.parse(await readFile(join(root, 'orionplace/settings.json'), 'utf8'));
+  let settings   = await read();
+  const ask      = process.stdin.isTTY && !yes;
+  if (!settings.backend) {
+    if (!ask) throw new Error(`Set the personal backend first: npx orionplace-${framework.id} set backend my-shop.orionplace.app`);
+    log('Your personal backend is shown in your orionmarket.place profile, for example my-shop.orionplace.app.');
+    await setupProject({ cwd: root, field: 'backend', value: await prompt('Personal backend domain: ') });
+    settings = await read();
+  }
+  if (!settings.frontends?.length) {
+    if (!ask) throw new Error(`Add the storefront domain first: npx orionplace-${framework.id} add frontend shop.example.com`);
+    await setupProject({ cwd: root, action: 'add', field: 'frontend', value: await prompt('Storefront domain (for example shop.example.com): ') });
+    settings = await read();
+  }
+  return settings;
+}
+
+// The storefront's home page as the public domain sees it -> HTTP status, 0 when down.
+export function homeStatus(port, host) {
+  return new Promise(done => {
+    const call = request({ host: '127.0.0.1', port, path: '/', headers: { host }, timeout: 15000 }, response => {
+      response.resume();
+      done(response.statusCode);
+    });
+    call.once('timeout', () => call.destroy());
+    call.once('error', () => done(0));
+    call.end();
+  });
+}
+
+export async function waitForHttp(port, host, seconds = 90) {
+  const until = Date.now() + seconds * 1000;
+  while (Date.now() < until) {
+    const status = await homeStatus(port, host);
+    if (status) return status;
+    await new Promise(done => setTimeout(done, 1000));
+  }
+  return 0;
+}
+
+export async function installService({
+  cwd = process.cwd(), name, port, user, build = true, domains = true, yes = false, dryRun = false,
+  paths = defaultPaths, run = runCommand, uid = process.getuid?.(), isFree = portIsFree,
+  systemd = existsSync('/run/systemd/system'), node = stableNode(),
+} = {}) {
+  if (process.platform !== 'linux') throw new Error('install sets up a Linux server service. Run it on your VPS.');
+  if (uid !== 0 && !dryRun) throw new Error(`install needs root: sudo npx orionplace-${framework.id} install`);
+  const root     = resolve(cwd);
+  if (!/^\/[A-Za-z0-9._/@+-]+$/.test(root)) throw new Error(`Use a storefront folder path without spaces or special characters (for example ${paths.srv}/shop), not ${root}.`);
+  let pkg;
+  try { pkg = JSON.parse(await readFile(join(root, 'package.json'), 'utf8')); }
+  catch { throw new Error(`Run install in your storefront folder (created with: npx orionplace-${framework.id} init).`); }
+  if (!{ ...pkg.devDependencies, ...pkg.dependencies }[framework.dependency] || !existsSync(join(root, 'orionplace/settings.json'))) {
+    throw new Error(`This folder is not an Orionplace ${framework.title} storefront. Run install in the folder created with: npx orionplace-${framework.id} init`);
+  }
+  const openrc   = !systemd && existsSync('/sbin/openrc-run');
+  if (!systemd && !openrc && !dryRun) throw new Error('Neither systemd nor OpenRC was found; start the storefront with your own process manager (see orionplace/README.md, Deploy on your VPS).');
+
+  const settings = dryRun ? JSON.parse(await readFile(join(root, 'orionplace/settings.json'), 'utf8')) : await ensureDomains(root, { yes });
+  const apps     = await readApps(paths);
+  const previous = apps.find(app => app.DIR === root);
+  const service  = serviceName(name || previous?.NAME || basename(root));
+  if (apps.some(app => app.NAME === service && app.DIR !== root)) {
+    throw new Error(`Another storefront already uses the name ${service} (${apps.find(app => app.NAME === service).DIR}). Choose one with --name.`);
+  }
+  const chosen   = await choosePort(apps.filter(app => app.DIR !== root), port ? Number(port) : Number(previous?.PORT) || 0, isFree);
+
+  // The service runs as the folder's owner, or as "orionplace" for root-owned folders.
+  const owner    = await stat(root);
+  let account    = user ? await passwdEntry(user) : owner.uid === 0 ? await passwdEntry(SERVICE_USER) : await userByUid(owner.uid);
+  if (user && !account) throw new Error(`No system user ${user}.`);
+  if (!account && !dryRun) {
+    if (existsSync('/usr/sbin/useradd') || existsSync('/sbin/useradd')) {
+      await run('useradd', ['--system', '--home-dir', paths.srv, '--shell', '/sbin/nologin', '--user-group', SERVICE_USER], { capture: true });
+    } else {
+      await run('addgroup', ['-S', SERVICE_USER], { capture: true });
+      await run('adduser', ['-S', '-D', '-H', '-h', paths.srv, '-s', '/sbin/nologin', '-G', SERVICE_USER, SERVICE_USER], { capture: true });
+    }
+    account = await passwdEntry(SERVICE_USER);
+    if (!account) throw new Error(`Could not create the system user ${SERVICE_USER}.`);
+  }
+  account      ||= { name: SERVICE_USER, uid: -1, gid: -1 };
+  const group    = account.gid >= 0 ? (await readFile('/etc/group', 'utf8')).split('\n').map(line => line.split(':'))
+    .find(([, , gid]) => Number(gid) === account.gid)?.[0] || account.name : account.name;
+  if (account.uid >= 0) await checkReachable(root, account);
+
+  const values   = { name: service, root, user: account.name, group, port: chosen, node, env: framework.environment, logs: paths.logs };
+  const unitPath = systemd ? join(paths.systemd, `orionplace-${service}.service`) : join(paths.openrc, `orionplace-${service}`);
+  const unit     = systemd ? systemdUnit(values) : openrcScript(values);
+  const conf     = [
+    `# Managed by orionplace-${framework.id} install. Use "orionplace app" commands to change it.`,
+    `NAME=${service}`, `FRAMEWORK=${framework.id}`, `DIR=${root}`, `PORT=${chosen}`,
+    `USER=${account.name}`, `NODE=${node}`, `SERVICE=orionplace-${service}`, '',
+  ].join('\n');
+  if (dryRun) {
+    return { dryRun, name: service, port: chosen, user: account.name, unitPath, unit, conf, frontends: settings.frontends || [], backend: settings.backend };
+  }
+
+  const rebuild  = build || !existsSync(join(root, framework.output));
+  log(rebuild ? `\n==> Building the ${framework.title} storefront ${service}` : `\n==> Using the existing build of ${service} (--no-build)`);
+  // The website build; ORIONPLACE_APP_ORIGIN would make the Android app build.
+  const buildEnv = { ...process.env };
+  delete buildEnv.ORIONPLACE_APP_ORIGIN;
+  if (!existsSync(join(root, 'node_modules', framework.dependency))) {
+    const installed = await run('npm', ['install', '--no-audit', '--no-fund'], { cwd: root, env: buildEnv });
+    if (installed.code) throw new Error('npm install failed; see the messages above.');
+  }
+  if (rebuild) {
+    const built = await run('npm', ['run', 'build'], { cwd: root, env: buildEnv });
+    if (built.code) throw new Error('The build failed; see the messages above. The running service (if any) was not changed.');
+  }
+  if (!existsSync(join(root, framework.output))) throw new Error(`The build did not produce ${framework.output}.`);
+  const owned    = await run('chown', ['-R', `${account.uid}:${account.gid}`, root], { capture: true });
+  if (owned.code) throw new Error(`Could not give ${root} to ${account.name}:\n${owned.output}`);
+
+  log(`\n==> Installing the service orionplace-${service} on port ${chosen}`);
+  await writeAtomic(unitPath, unit, systemd ? 0o644 : 0o755);
+  await writeAtomic(join(paths.etc, 'apps', `${service}.conf`), conf);
+  const steps    = systemd
+    ? [['systemctl', ['daemon-reload']], ['systemctl', ['enable', `orionplace-${service}`]], ['systemctl', ['restart', `orionplace-${service}`]]]
+    : [['rc-update', ['add', `orionplace-${service}`, 'default']], ['rc-service', [`orionplace-${service}`, 'restart']]];
+  for (const [command, args] of steps) {
+    const result = await run(command, args, { capture: true });
+    if (result.code) throw new Error(`${command} ${args.join(' ')} failed:\n${result.output}`);
+  }
+  const status   = await waitForHttp(chosen, settings.frontends[0]);
+  if (!status) {
+    const logs = systemd
+      ? await run('journalctl', ['-u', `orionplace-${service}`, '-n', '40', '--no-pager'], { capture: true })
+      : await run('tail', ['-n', '40', join(paths.logs, `${service}.log`)], { capture: true });
+    throw new Error(`The storefront did not start on port ${chosen}. Last log lines:\n${logs.output}`);
+  }
+  log(`  ✓ orionplace-${service} answers on 127.0.0.1:${chosen} (HTTP ${status})`);
+
+  const tool     = paths.tool.find(path => existsSync(path));
+  const failed   = [];
+  if (domains && tool) {
+    for (const domain of settings.frontends) {
+      log(`\n==> Connecting ${domain}`);
+      const backend = settings.backend.replace(/^https:\/\//, '').replace(/\/api$/, '');
+      const result  = await run(tool, ['domain', 'add', domain, '--app', service, '--backend', backend, '--yes']);
+      if (result.code) failed.push(domain);
+    }
+  } else if (domains) {
+    log('\nThe orionplace server tool is not set up, so nginx and HTTPS were not configured. Prepare the server:');
+    log('  curl -fsSLo orionplace.sh https://orionmarket.place/downloads/orionplace.sh && sudo sh orionplace.sh setup');
+    log(`Then run this install again. Or proxy your HTTPS site to http://127.0.0.1:${chosen} as orionplace/README.md describes.`);
+  }
+  return { name: service, port: chosen, user: account.name, unitPath, frontends: settings.frontends, failed, connected: domains && Boolean(tool) };
+}

package/src/project-readme.mjs

@@ -513,6 +513,16 @@ If installation fails after source generation, run \`npm install\` and retry.
 
 ## Deploy on your VPS
 
+The quickest way: prepare the server with the OrionMarketplace server script,
+then run \`sudo npx orionplace-nuxt install\` in this folder. It builds the
+project, runs it as a system service and connects your domains with nginx and
+HTTPS. Steps: [Install a storefront](https://orionmarket.place/en/sandbox/install/storefront).
+Then manage it from this folder: \`npx orionplace-nuxt status\`, \`sudo npx orionplace-nuxt restart\`,
+\`sudo npx orionplace-nuxt stop\`, \`sudo npx orionplace-nuxt start\` and \`sudo npx orionplace-nuxt logs\`.
+\`sudo npx orionplace-nuxt uninstall\` (or \`cleanup\`) stops and removes the service; this folder stays.
+
+To set the server up yourself instead:
+
 This integration needs a Node.js server and its domain configuration files.
 It does not support static-only or edge hosting. Deploy the build, dependencies,
 \`sitemaps\`, and your environment configuration together; use an absolute

package/src/service.mjs

@@ -0,0 +1,186 @@
+// Manages the storefront service that "install" set up: start, stop, restart,
+// status, logs and the list of every storefront service on this server.
+// The service is found by its folder (the project root) or by --name.
+import { existsSync } from 'node:fs';
+import { readFile, rm } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { defaultPaths, framework, homeStatus, readApps, runCommand, waitForHttp } from './install.mjs';
+
+export const SERVICE_ACTIONS = ['start', 'stop', 'restart', 'status', 'logs', 'list', 'uninstall'];
+// "cleanup" is another name for uninstall.
+export const SERVICE_ALIASES = { cleanup: 'uninstall' };
+
+async function frontends(dir) {
+  try { return JSON.parse(await readFile(join(dir, 'orionplace/settings.json'), 'utf8')).frontends || []; }
+  catch { return []; }
+}
+
+// The registered storefront of this folder, or the one named with --name.
+export async function findApp({ cwd = process.cwd(), name, paths = defaultPaths } = {}) {
+  const apps = await readApps(paths);
+  const root = resolve(cwd);
+  const app  = name ? apps.find(item => item.NAME === name) : apps.find(item => item.DIR === root);
+  if (app) return app;
+  const known = apps.map(item => item.NAME).join(', ');
+  if (name) throw new Error(`No storefront service named ${name}.${known ? ` Installed: ${known}.` : ''}`);
+  throw new Error(`${root} is not installed as a service. Install it first: sudo npx orionplace-${framework.id} install`
+    + (known ? `\nOr name another storefront: --name ${apps[0].NAME} (installed: ${known})` : ''));
+}
+
+// true / false; "unknown" when neither systemd nor OpenRC answers.
+async function isRunning(service, { run, systemd }) {
+  const result = systemd
+    ? await run('systemctl', ['is-active', '--quiet', service], { capture: true })
+    : await run('rc-service', [service, 'status'], { capture: true });
+  return result.code === 0;
+}
+
+async function isEnabled(service, { run, systemd }) {
+  const result = systemd
+    ? await run('systemctl', ['is-enabled', '--quiet', service], { capture: true })
+    : await run('rc-update', ['show', 'default'], { capture: true });
+  return systemd ? result.code === 0 : new RegExp(`^\\s*${service}\\s`, 'm').test(result.output);
+}
+
+async function lastLogs(app, { run, systemd, paths, lines = 40 }) {
+  const result = systemd
+    ? await run('journalctl', ['-u', app.SERVICE || `orionplace-${app.NAME}`, '-n', String(lines), '--no-pager'], { capture: true })
+    : await run('tail', ['-n', String(lines), join(paths.logs, `${app.NAME}.log`)], { capture: true });
+  return result.output;
+}
+
+// One storefront's state: service, autostart, and the home page as its first domain sees it.
+export async function serviceStatus(app, { run = runCommand, systemd = existsSync('/run/systemd/system'), probe = homeStatus } = {}) {
+  const service = app.SERVICE || `orionplace-${app.NAME}`;
+  const domains = await frontends(app.DIR);
+  const running = await isRunning(service, { run, systemd });
+  const enabled = await isEnabled(service, { run, systemd });
+  const http    = running ? await probe(Number(app.PORT), domains[0] || 'localhost') : 0;
+  return { name: app.NAME, service, framework: app.FRAMEWORK, dir: app.DIR, port: Number(app.PORT), running, enabled, http, domains };
+}
+
+/**
+ * controlService({ action, cwd, name, lines, follow }) runs one action and
+ * returns what happened; logs and follow print straight to the terminal.
+ */
+export async function controlService({
+  action, cwd = process.cwd(), name, lines = 100, follow = false,
+  paths = defaultPaths, run = runCommand, uid = process.getuid?.(),
+  systemd = existsSync('/run/systemd/system'), openrc = existsSync('/sbin/openrc-run'),
+  platform = process.platform, probe = homeStatus, wait = waitForHttp, dryRun = false,
+} = {}) {
+  action = SERVICE_ALIASES[action] || action;
+  if (!SERVICE_ACTIONS.includes(action)) throw new Error(`Unknown service command ${action}. Use ${SERVICE_ACTIONS.join(', ')}.`);
+  if (platform !== 'linux') throw new Error(`${action} manages the Linux service that install set up. Run it on your server.`);
+  if (!systemd && !openrc) throw new Error('Neither systemd nor OpenRC was found on this server.');
+
+  if (action === 'list') {
+    const apps = await readApps(paths);
+    return { action, apps: await Promise.all(apps.map(app => serviceStatus(app, { run, systemd, probe }))) };
+  }
+
+  const app     = await findApp({ cwd, name, paths });
+  const service = app.SERVICE || `orionplace-${app.NAME}`;
+  if (action === 'status') return { action, ...await serviceStatus(app, { run, systemd, probe }) };
+
+  if (action === 'logs') {
+    const count = Number(lines);
+    if (!Number.isInteger(count) || count < 1) throw new Error('Give the number of log lines as a whole number, for example: logs 200');
+    const args  = systemd
+      ? ['journalctl', ['-u', service, '-n', String(count), '--no-pager', ...(follow ? ['--follow'] : [])]]
+      : ['tail', ['-n', String(count), ...(follow ? ['-F'] : []), join(paths.logs, `${app.NAME}.log`)]];
+    const result = await run(...args);
+    if (result.code) throw new Error(`${args[0]} could not read the logs of ${service}${uid !== 0 ? `; try: sudo npx orionplace-${framework.id} logs` : ''}.`);
+    return { action, name: app.NAME, service };
+  }
+
+  if (action === 'uninstall') return uninstallService(app, { paths, run, uid, systemd, name, dryRun });
+  if (uid !== 0) throw new Error(`${action} needs root: sudo npx orionplace-${framework.id} ${action}${name ? ` --name ${name}` : ''}`);
+  const result  = systemd
+    ? await run('systemctl', [action, service], { capture: true })
+    : await run('rc-service', [service, action], { capture: true });
+  if (result.code) throw new Error(`Could not ${action} ${service}:\n${result.output.trim()}`);
+  if (action === 'stop') return { action, name: app.NAME, service, running: false };
+
+  const domains = await frontends(app.DIR);
+  const http    = await wait(Number(app.PORT), domains[0] || 'localhost', 90);
+  if (!http) {
+    throw new Error(`${service} did not answer on port ${app.PORT} within 90 seconds. Last log lines:\n${await lastLogs(app, { run, systemd, paths })}`);
+  }
+  return { action, name: app.NAME, service, port: Number(app.PORT), running: true, http, domains };
+}
+
+/**
+ * Stops the service, removes it from autostart, deletes its unit or init
+ * script and its registration. The project folder and its build stay. With
+ * the orionplace server tool, "orionplace app remove" does it and also turns
+ * the storefront's domains into a placeholder page.
+ */
+async function uninstallService(app, { paths, run, uid, systemd, name, dryRun }) {
+  const service  = app.SERVICE || `orionplace-${app.NAME}`;
+  const unitPath = systemd ? join(paths.systemd, `${service}.service`) : join(paths.openrc, service);
+  const confPath = join(paths.etc, 'apps', `${app.NAME}.conf`);
+  const tool     = (paths.tool || []).find(path => existsSync(path));
+  const result   = { action: 'uninstall', name: app.NAME, service, dir: app.DIR, domains: await frontends(app.DIR), tool: Boolean(tool), unitPath, confPath, dryRun };
+  if (dryRun) return result;
+  if (uid !== 0) throw new Error(`uninstall needs root: sudo npx orionplace-${framework.id} uninstall${name ? ` --name ${name}` : ''}`);
+  if (tool) {
+    const removed = await run(tool, ['app', 'remove', app.NAME, '--yes']);
+    if (removed.code) throw new Error(`orionplace app remove ${app.NAME} failed; see the messages above.`);
+    return result;
+  }
+  // A service that is already stopped or missing is fine: the goal is that it is gone.
+  if (systemd) await run('systemctl', ['disable', '--now', service], { capture: true });
+  else {
+    await run('rc-service', [service, 'stop'], { capture: true });
+    await run('rc-update', ['del', service, 'default'], { capture: true });
+  }
+  await rm(unitPath, { force: true });
+  if (systemd) await run('systemctl', ['daemon-reload'], { capture: true });
+  await rm(confPath, { force: true });
+  return result;
+}
+
+// The CLI output of controlService; returns the process exit code.
+export function printService(result, log = console.log) {
+  const line = item => {
+    const state = item.running ? (item.http ? `running, home page HTTP ${item.http}` : 'running, home page does not answer') : 'stopped';
+    return `${item.name.padEnd(16)} ${String(item.framework || '').padEnd(7)} ${String(item.port).padEnd(6)} ${state}`;
+  };
+  if (result.action === 'list') {
+    if (!result.apps.length) {
+      log(`No storefront services on this server. Install one from its folder: sudo npx orionplace-${framework.id} install`);
+      return 0;
+    }
+    log(`${'NAME'.padEnd(16)} ${'TYPE'.padEnd(7)} ${'PORT'.padEnd(6)} STATE`);
+    for (const item of result.apps) log(line(item));
+    return 0;
+  }
+  if (result.action === 'status') {
+    log(`${result.service} (${result.framework || framework.id}) in ${result.dir}`);
+    log(`  Service:   ${result.running ? 'running' : 'stopped'}${result.enabled ? ', starts with the server' : ', does not start with the server'}`);
+    log(`  Port:      127.0.0.1:${result.port}`);
+    log(`  Home page: ${result.running ? (result.http ? `HTTP ${result.http}` : 'does not answer') : '-'}`);
+    for (const domain of result.domains) log(`  Domain:    https://${domain}`);
+    return result.running && result.http && result.http < 500 ? 0 : 3;
+  }
+  if (result.action === 'uninstall') {
+    if (result.dryRun) {
+      log(`Would stop and remove ${result.service}:`);
+      log(result.tool ? `  orionplace app remove ${result.name} --yes (also turns its domains into a placeholder)` : `  ${result.unitPath}\n  ${result.confPath}`);
+      log(`The project stays in ${result.dir}.`);
+      return 0;
+    }
+    log(`Removed the service ${result.service}. The project and its build stay in ${result.dir}; delete the folder when you no longer need it.`);
+    if (!result.tool && result.domains.length) {
+      log(`nginx still sends ${result.domains.join(', ')} to the stopped service; remove those sites from your nginx configuration.`);
+    }
+    log(`Install it again with: sudo npx orionplace-${framework.id} install`);
+    return 0;
+  }
+  if (result.action === 'stop') log(`Stopped ${result.service}.`);
+  else if (result.action === 'start' || result.action === 'restart') {
+    log(`${result.action === 'start' ? 'Started' : 'Restarted'} ${result.service}: home page HTTP ${result.http} on 127.0.0.1:${result.port}.`);
+  }
+  return 0;
+}

package/templates/app/components/orionplace/subscriptions/StorefrontTariff.vue

@@ -20,6 +20,7 @@
     tariffMediaItems,
     tariffPagePath,
   } from '@/utils/orionplace/tariffPage';
+  import { tariffResumable } from '@/utils/orionplace/tariffs';
   import {
     getAvailableNestedValueFromObject,
     plainText,
@@ -74,6 +75,18 @@
   const tariff     = computed(() =>
     confirmed.value ? catalogStore.getTariff(props.tariffId) : undefined,
   );
+  /*
+   * A trial chosen before sign-in opens again only once the customer's
+   * subscription records are known and the customer is new to this one;
+   * the backend refuses a trial to a returning customer.
+   */
+  const resumable  = computed(() =>
+    tariffResumable(
+      props.resume,
+      tariff.value,
+      catalogStore.usedSubscriptionsOf(store.profile?.id),
+    ),
+  );
   // The heading names the plan; `tariff_title` is its SEO page title.
   const title      = computed(
     () =>
@@ -190,6 +203,7 @@
     if (!confirmed.value) {
       void load();
     }
+    void account.loadUsed();
   });
 
   watch(media, () => {
@@ -201,7 +215,13 @@
     }
   });
   watch(
-    () => props.resume,
+    () => store.profile?.id,
+    () => {
+      void account.loadUsed();
+    },
+  );
+  watch(
+    resumable,
     (value) => {
       if (
         value?.tariff === props.tariffId &&

package/templates/app/components/orionplace/subscriptions/StorefrontTariffs.vue

@@ -1,10 +1,11 @@
 <script setup lang="ts">
-  import { computed, onMounted, ref } from 'vue';
+  import { computed, onMounted, ref, watch } from 'vue';
   import { NuxtLink } from '#components';
   import { useOrionplaceStore } from '@/stores/orionplace';
   import { useOrionplaceCatalogStore } from '@/stores/orionplaceCatalog';
   import { useOrionplaceSelectionsStore } from '@/stores/orionplaceSelections';
   import { useOrionplaceSubscriptions } from '@/composables/useOrionplaceSubscriptions';
+  import { tariffResumable } from '@/utils/orionplace/tariffs';
   import {
     useOrionplaceFeatureApi,
     useOrionplaceTask,
@@ -47,7 +48,20 @@
   const busy           = computed(() =>
     Boolean(task.state.pending || account.task.state.pending),
   );
-  const open     = computed(() => (guest.value ? undefined : props.resume));
+  /*
+   * The choice to reopen after sign-in. A trial waits for the customer's
+   * subscription records and opens only for a customer new to the record;
+   * the backend refuses a trial to a returning customer.
+   */
+  const open     = computed(() =>
+    guest.value
+      ? undefined
+      : tariffResumable(
+          props.resume,
+          props.resume && catalogStore.getTariff(props.resume.tariff),
+          catalogStore.usedSubscriptionsOf(store.profile?.id),
+        ),
+  );
   // The plans this page shows: every loaded plan, or only the requested IDs.
   const shown    = computed(() => {
     const data = catalogStore.tariffs?.data ?? [];
@@ -141,7 +155,14 @@
     if (!catalogStore.tariffs || catalogStore.tariffsSnapshot) {
       void load();
     }
+    void account.loadUsed();
   });
+  watch(
+    () => store.profile?.id,
+    () => {
+      void account.loadUsed();
+    },
+  );
 </script>
 <template>
   <section

package/templates/app/components/orionplace/tariffs/TariffCard.vue

@@ -104,11 +104,13 @@
 <script setup lang="ts">
   import { computed, ref, watch } from 'vue';
   import { NuxtLink } from '#components';
+  import { useOrionplaceStore } from '@/stores/orionplace';
   import { useOrionplaceCatalogStore } from '@/stores/orionplaceCatalog';
   import { useOrionplaceSelectionsStore } from '@/stores/orionplaceSelections';
   import {
     tariffIsOpen,
     tariffSubscribeRequest,
+    tariffTrialOpen,
   } from '@/utils/orionplace/tariffs';
   import {
     tariffDays,
@@ -164,6 +166,7 @@
     select: [selection: ITariffSelection];
     subscribe: [request: ITariffSubscribeRequest];
   }>();
+  const store          = useOrionplaceStore();
   const catalogStore   = useOrionplaceCatalogStore();
   const selectionStore = useOrionplaceSelectionsStore();
   const tariff         = computed(() => catalogStore.getTariff(props.tariffId));
@@ -178,15 +181,22 @@
   // The option chosen in the card; the dialog opens on it and keeps its own
   // choice from there.
   const optionId   = ref<number>();
+  // No trial badge for a customer who already had this subscription record.
   const trialBadge = computed(() => {
-    const days = tariff.value?.trial_days ?? 0;
+    const value = tariff.value;
 
-    if (days <= 0) {
+    if (
+      !value ||
+      !tariffTrialOpen(
+        value,
+        catalogStore.usedSubscriptionsOf(store.profile?.id),
+      )
+    ) {
       return '';
     }
 
     return tariffText(tariffLabels(selectionStore.localeCode).trialBadge, {
-      days: tariffDays(days, selectionStore.localeCode),
+      days: tariffDays(value.trial_days, selectionStore.localeCode),
     });
   });
 

package/templates/app/components/orionplace/tariffs/TariffCardPrices.README.md

@@ -1,6 +1,6 @@
 # TariffCardPrices · Nuxt
 
-The period switcher, the price for the chosen period and the Subscribe and Try actions. A plan that only the store administrator assigns, or a plan that no longer accepts new subscriptions, shows a note instead of actions. The plan and its parent subscription each carry `is_new_subs_allowed` and `only_admin_can_subscribe`, and both have to allow the purchase.
+The period switcher, the price for the chosen period and the Subscribe and Try actions. A plan that only the store administrator assigns, or a plan that no longer accepts new subscriptions, shows a note instead of actions. The plan and its parent subscription each carry `is_new_subs_allowed` and `only_admin_can_subscribe`, and both have to allow the purchase. A signed-in customer who already had the plan's subscription sees no Try action and no trial badge: the backend gives a trial once per subscription. The plan pages load the customer's records with `subscriptions_get`; until they arrive, the trial stays shown.
 
 [English guide](https://orionmarket.place/en/sandbox/components/nuxt/tariff-prices) ·
 [Russian guide](https://orionmarket.place/ru/sandbox/components/nuxt/tariff-prices)

package/templates/app/components/orionplace/tariffs/TariffCardPrices.vue

@@ -116,6 +116,7 @@
 </template>
 <script setup lang="ts">
   import { computed, useId } from 'vue';
+  import { useOrionplaceStore } from '@/stores/orionplace';
   import { useOrionplaceCatalogStore } from '@/stores/orionplaceCatalog';
   import { useOrionplaceSelectionsStore } from '@/stores/orionplaceSelections';
   import { useOrionplaceSignIn } from '@/composables/useOrionplaceSignIn';
@@ -125,6 +126,7 @@
     tariffMoney,
     tariffPaidPeriods,
     tariffReturnPath,
+    tariffTrialOpen,
   } from '@/utils/orionplace/tariffs';
   import {
     tariffDays,
@@ -155,6 +157,7 @@
   // The chosen paid period as its `tariff_cost_id`.
   const selectedPeriod = defineModel<number>();
   const emit           = defineEmits<{ select: [selection: ITariffSelection] }>();
+  const store          = useOrionplaceStore();
   const catalogStore   = useOrionplaceCatalogStore();
   const selectionStore = useOrionplaceSelectionsStore();
   const signIn         = useOrionplaceSignIn();
@@ -194,11 +197,24 @@
       paidPeriods.value.find((item) => item.price === selectedPeriod.value) ??
       paidPeriods.value[0],
   );
-  const trialDuration  = computed(() => {
-    const days = tariff.value?.trial_days ?? 0;
+  // A customer who already had this subscription record gets no trial.
+  const trialUsed      = computed(() => {
+    const value = tariff.value;
 
-    return days > 0 ? duration(days) : '';
+    return Boolean(
+      value &&
+        value.trial_days > 0 &&
+        !tariffTrialOpen(
+          value,
+          catalogStore.usedSubscriptionsOf(store.profile?.id),
+        ),
+    );
   });
+  const trialDuration  = computed(() =>
+    tariff.value && !trialUsed.value && tariff.value.trial_days > 0
+      ? duration(tariff.value.trial_days)
+      : '',
+  );
   const actions        = computed(() => {
     const list: TariffPeriodAction[] = [];
 
@@ -237,7 +253,11 @@
       return copy.value.closed;
     }
 
-    return actions.value.length ? '' : copy.value.noPeriods;
+    if (actions.value.length) {
+      return '';
+    }
+
+    return trialUsed.value ? copy.value.trialUsed : copy.value.noPeriods;
   });
   const actionClasses  = `
     box-border inline-flex h-11 w-full items-center justify-center px-6

package/templates/app/composables/useOrionplaceSubscriptions.ts

@@ -1,10 +1,12 @@
 import { onMounted, ref, shallowRef, watch } from 'vue';
 import { useOrionplaceStore } from '@/stores/orionplace';
+import { useOrionplaceCatalogStore } from '@/stores/orionplaceCatalog';
 import {
   useOrionplaceFeatureApi,
   useOrionplaceTask,
 } from '@/composables/useOrionplaceFeature';
 import { useOrionplaceSignIn } from '@/composables/useOrionplaceSignIn';
+import { tariffUsedSubscriptions } from '@/utils/orionplace/tariffs';
 import type {
   ICustomerSubscription,
   ICustomerSubscriptionsResponse,
@@ -19,6 +21,7 @@ import type { IProfileData } from '@/interfaces/orionplace/accounts/IProfileData
 
 export function useOrionplaceSubscriptions(loadOnMount = true) {
   const store         = useOrionplaceStore();
+  const catalogStore  = useOrionplaceCatalogStore();
   const api           = useOrionplaceFeatureApi();
   const task          = useOrionplaceTask();
   const signIn        = useOrionplaceSignIn();
@@ -38,6 +41,7 @@ export function useOrionplaceSubscriptions(loadOnMount = true) {
     subscriptions.value = result.data;
     tariffs.value       = result.tariffs;
     loaded.value        = true;
+    rememberUsed(result);
     const profileData   = await api.request<{ profile_info: IProfileData[] }>(
       'profile_get',
       { filters: {} },
@@ -58,6 +62,44 @@ export function useOrionplaceSubscriptions(loadOnMount = true) {
     }
   }
 
+  function rememberUsed(
+    result: NonNullable<ICustomerSubscriptionsResponse['page_data']>,
+  ) {
+    if (store.profile) {
+      catalogStore.setUsedSubscriptions(
+        store.profile.id,
+        tariffUsedSubscriptions(result),
+      );
+    }
+  }
+
+  /*
+   * The plan pages hide the trial of a subscription record the customer
+   * already had (the backend refuses it). They read the records once per
+   * profile; a failed read leaves the trial shown, as for an unknown customer.
+   */
+  async function loadUsed() {
+    const profile = store.profile?.id;
+
+    if (
+      !store.isAuthenticated ||
+      profile === undefined ||
+      catalogStore.usedSubscriptionsOf(profile)
+    ) {
+      return;
+    }
+    try {
+      rememberUsed(
+        await api.request<NonNullable<ICustomerSubscriptionsResponse['page_data']>>(
+          'subscriptions_get',
+          {},
+        ),
+      );
+    } catch {
+      catalogStore.setUsedSubscriptions(profile, []);
+    }
+  }
+
   /*
    * Each plan the customer buys is its own subscription, so a purchase that
    * already succeeded must not block the next one. Only repeating the same
@@ -206,6 +248,7 @@ export function useOrionplaceSubscriptions(loadOnMount = true) {
     completed,
     needsRefresh,
     load,
+    loadUsed,
     subscribe,
     renew,
     setRenewal,

package/templates/app/stores/orionplaceCatalog.ts

@@ -17,6 +17,9 @@ import { resolveAppLoadProducts } from '@/utils/orionplace/productSeller';
  * `storeTariffs` is every plan the storefront sells; the subscriptions page
  * and its dialogs read it. `tariffs` is what the plan pages show: the same
  * list, or a search result or one plan set with `setTariffs`.
+ * `usedSubscriptions` holds the subscription records the signed-in customer
+ * already had, for the profile that loaded them; a new Application Load
+ * keeps it, another profile ignores it.
  */
 export function useOrionplaceCatalog(
   scope: string,
@@ -27,6 +30,7 @@ export function useOrionplaceCatalog(
     const catalogSnapshot      = shallowRef<NonNullable<IAppLoadCommon['catalog']>>();
     const tariffsSnapshot      = shallowRef<NonNullable<IAppLoadCommon['tariffs']>>();
     const storeTariffsSnapshot = shallowRef<NonNullable<IAppLoadCommon['tariffs']>>();
+    const usedSubscriptions    = shallowRef<{ profile: number; ids: number[] }>();
     const catalog              = computed(
       () => catalogSnapshot.value ?? init.value?.catalog ?? [],
     );
@@ -68,6 +72,19 @@ export function useOrionplaceCatalog(
       tariffsSnapshot.value      = undefined;
     }
 
+    /** The records the customer had, see `tariffUsedSubscriptions`. */
+    function setUsedSubscriptions(profile: number, ids: number[]) {
+      usedSubscriptions.value = { profile, ids };
+    }
+
+    /** Those records for this profile; undefined until they are loaded. */
+    function usedSubscriptionsOf(profile: number | undefined) {
+      return usedSubscriptions.value &&
+        usedSubscriptions.value.profile === profile
+        ? usedSubscriptions.value.ids
+        : undefined;
+    }
+
     function getTariff(id: number) {
       return tariffs.value?.data.find((tariff) => tariff.id === id);
     }
@@ -94,6 +111,7 @@ export function useOrionplaceCatalog(
       catalogSnapshot,
       tariffsSnapshot,
       storeTariffsSnapshot,
+      usedSubscriptions,
       catalog,
       tariffs,
       storeTariffs,
@@ -105,6 +123,8 @@ export function useOrionplaceCatalog(
       setCatalogTree,
       setTariffs,
       setStoreTariffs,
+      setUsedSubscriptions,
+      usedSubscriptionsOf,
       getTariff,
       getCatalogCategory,
       getCatalogProducts,

package/templates/app/utils/orionplace/api.ts

@@ -190,8 +190,8 @@ export class OrionplaceApi {
     const body             = response.body as {
       page_data?: { csrf?: boolean };
     } | null;
-    // Only a CSRF rejection permits one automatic retry: Django views answer
-    // 419, API endpoints answer 403 with page_data.csrf set to false.
+    // A CSRF rejection: Django views answer 419, API endpoints answer 403
+    // with page_data.csrf set to false. The request is not repeated.
     const csrfRejected     =
       response.status === 419 ||
       (response.status === 403 && body?.page_data?.csrf === false);

package/templates/app/utils/orionplace/tariffLabels.ts

@@ -9,6 +9,7 @@ const labels = {
     adminOnly:
       'This plan is assigned by the store administrator. It cannot be subscribed to online.',
     closed: 'New subscriptions to this plan are closed.',
+    trialUsed: 'You have already used the trial of this subscription.',
     subscribe: 'Subscribe',
     tryTrial: 'Try',
     perPeriod: 'for {days}',
@@ -57,6 +58,7 @@ const labels = {
     adminOnly:
       'Этот тариф подключает администратор магазина. Самостоятельное подключение недоступно.',
     closed: 'Новые подключения к этому тарифу закрыты.',
+    trialUsed: 'Пробный период этой подписки вы уже использовали.',
     subscribe: 'Подключить',
     tryTrial: 'Попробовать',
     perPeriod: 'за {days}',

package/templates/app/utils/orionplace/tariffs.ts

@@ -201,6 +201,55 @@ export function tariffSubscribeRequest(
   };
 }
 
+/**
+ * The subscription records the customer already had a period of, paid or
+ * trial, read from the `subscriptions_get` response. The backend gives a trial
+ * only to a customer new to the record, so the plans of these records offer
+ * none.
+ */
+export function tariffUsedSubscriptions(page: {
+  data: { subscription: number | null; tariff: number | null }[];
+  tariffs: { id: number; subscription: number }[];
+}) {
+  const ids = page.data.map(
+    (item) =>
+      item.subscription ??
+      page.tariffs.find((tariff) => tariff.id === item.tariff)?.subscription,
+  );
+
+  return [...new Set(ids.filter((id): id is number => typeof id === 'number'))];
+}
+
+/**
+ * Whether the plan offers its trial: it has trial days and the customer is
+ * not known to have had its subscription record (`used`, see
+ * `tariffUsedSubscriptions`). A guest and a customer whose records are not
+ * loaded yet see the trial; the backend refuses it to a returning customer.
+ */
+export function tariffTrialOpen(
+  tariff: ISubscribeTariff,
+  used: readonly number[] = [],
+) {
+  return tariff.trial_days > 0 && !used.includes(tariff.subscription);
+}
+
+/**
+ * The plan choice to open again after sign-in: a paid period as it is, a
+ * trial only once the customer's records are loaded (`used`) and the
+ * customer is new to the record.
+ */
+export function tariffResumable(
+  selection: ITariffSelection | undefined,
+  tariff: ISubscribeTariff | undefined,
+  used: readonly number[] | undefined,
+) {
+  if (!selection || selection.price !== null) {
+    return selection;
+  }
+
+  return tariff && used && tariffTrialOpen(tariff, used) ? selection : undefined;
+}
+
 export interface ITariffFeature {
   key: string;
   label: string;

package/templates/orionplace/COMPONENTS.md

@@ -705,7 +705,11 @@ the short description comes from `tariff_short_description` with HTML stripped,
 and the full `tariff_description` opens under Details after sanitizing. Both use
 available translation fallback. The image uses `tariff_image.small[0]`; a plan
 without it shows no picture and leaves that row of the card empty. A positive
-`trial_days` adds a trial badge.
+`trial_days` adds a trial badge and the Try action, except for a signed-in
+customer who already had the plan's subscription: the backend gives a trial
+once per subscription. The plan pages read the customer's records with
+`subscriptions_get` and keep them in the catalog store
+(`usedSubscriptionsOf(profileId)`).
 
 `TariffCardFeatures` lists the flags and numeric limits of
 `tariff_variables_json`: `true` is shown as included, `false` as not included,