@lamalibre/create-lamaste 4.0.0

package/vendor/server/src/commands/tunnels.js

@@ -0,0 +1,365 @@
+/**
+ * lamaste-server tunnels — Manage server tunnels.
+ *
+ * Subcommands:
+ *   list                                          List active tunnels
+ *   create --subdomain <s> --port <p> --agent <l> Create a tunnel carried by an agent
+ *   delete <id>                                   Delete a tunnel by ID
+ *   toggle <id> --enable|--disable                Enable or disable a tunnel
+ *   assign <id> --agent <label>                   Move a tunnel to another agent
+ *   configure <id> [--access-mode <m>] [--max-body-mb <n>]
+ *                                                 Change access mode / body limit
+ *
+ * List reads directly from the state file.
+ * Create/delete/toggle use the panel REST API (which has the full
+ * nginx/certbot/chisel dependency stack).
+ */
+
+import chalk from 'chalk';
+import { readTunnels } from '../state.js';
+import { panelRequest } from '../panel-api.js';
+import { emit, emitError, emitComplete } from '../ndjson.js';
+
+/**
+ * @param {string[]} args
+ * @param {{ json: boolean }} options
+ */
+export async function runTunnels(args, { json }) {
+  const sub = args[0];
+
+  switch (sub) {
+    case 'list':
+      return listTunnels({ json });
+    case 'create':
+      return createTunnel(args.slice(1), { json });
+    case 'delete':
+      return deleteTunnel(args[1], { json });
+    case 'toggle':
+      return toggleTunnel(args.slice(1), { json });
+    case 'assign':
+      return assignTunnel(args.slice(1), { json });
+    case 'configure':
+      return configureTunnel(args.slice(1), { json });
+    default:
+      printTunnelUsage();
+      process.exit(sub ? 1 : 0);
+  }
+}
+
+function printTunnelUsage() {
+  const b = chalk.bold;
+  const c = chalk.cyan;
+  console.log(`
+${b('Usage:')} lamaste-server tunnels <subcommand>
+
+${b('Subcommands:')}
+  ${c('list')}                                                List active tunnels
+  ${c('create')} --subdomain <s> --port <p> --agent <l> [opts] Create a tunnel
+  ${c('delete')} <id>                                         Delete a tunnel by ID
+  ${c('toggle')} <id> --enable|--disable                      Enable or disable a tunnel
+  ${c('assign')} <id> --agent <label>                         Move a tunnel to another agent
+  ${c('configure')} <id> [--access-mode <m>] [--max-body-mb <n>] Change access mode / body limit
+
+${b('Create options:')}
+  --subdomain <name>    Tunnel subdomain (required)
+  --port <number>       Local port to tunnel (required)
+  --agent <label>       Agent that carries the tunnel (required)
+  --description <text>  Optional description
+  --access-mode <mode>  Access mode: public, authenticated, restricted (default: restricted)
+  --max-body-mb <n>     Largest request body in MiB, 1-10240 (default: 10)
+`);
+}
+
+/**
+ * @param {{ json: boolean }} options
+ */
+async function listTunnels({ json }) {
+  const tunnels = await readTunnels();
+
+  if (json) {
+    emit({ tunnels });
+    return;
+  }
+
+  if (tunnels.length === 0) {
+    console.log('\n  No tunnels configured.\n');
+    return;
+  }
+
+  const b = chalk.bold;
+  const c = chalk.cyan;
+  const g = chalk.green;
+  const r = chalk.red;
+  const d = chalk.dim;
+
+  console.log('');
+  console.log(b('  Tunnels'));
+  console.log(d('  ' + '\u2500'.repeat(50)));
+
+  for (const t of tunnels) {
+    const enabled = t.enabled !== false ? g('enabled') : r('disabled');
+    const accessMode = t.accessMode ? d(`[${t.accessMode}]`) : '';
+    const type = t.type !== 'app' ? d(`(${t.type})`) : '';
+    const carrier = t.agentLabel ? d(`via ${t.agentLabel}`) : r('no agent');
+    const bodyLimit = t.type !== 'panel' ? d(`${t.maxBodySizeMb ?? 1} MiB`) : '';
+    console.log(
+      `  ${c(t.subdomain)} \u2192 :${t.port}  ${enabled} ${carrier} ${accessMode} ${bodyLimit} ${type}`.trimEnd(),
+    );
+    if (t.description) {
+      console.log(`    ${d(t.description)}`);
+    }
+    console.log(`    ${d(`id: ${t.id}  fqdn: ${t.fqdn}`)}`);
+  }
+  console.log('');
+}
+
+/**
+ * @param {string[]} args
+ * @param {{ json: boolean }} options
+ */
+async function createTunnel(args, { json }) {
+  const subdomain = getArg(args, 'subdomain');
+  const portStr = getArg(args, 'port');
+  const description = getArg(args, 'description') || undefined;
+  const accessMode = getArg(args, 'access-mode') || undefined;
+  const agentLabel = getArg(args, 'agent');
+  const maxBodyStr = getArg(args, 'max-body-mb');
+
+  if (!subdomain || !portStr || !agentLabel) {
+    const msg = 'Error: --subdomain, --port and --agent are required';
+    if (json) emitError(msg);
+    else console.error(`\n  ${msg}\n`);
+    process.exit(1);
+  }
+
+  const port = parseInt(portStr, 10);
+  if (isNaN(port) || port < 1 || port > 65535) {
+    const msg = 'Error: --port must be a valid port number (1-65535)';
+    if (json) emitError(msg);
+    else console.error(`\n  ${msg}\n`);
+    process.exit(1);
+  }
+
+  if (accessMode && !['public', 'authenticated', 'restricted'].includes(accessMode)) {
+    const msg = 'Error: --access-mode must be public, authenticated, or restricted';
+    if (json) emitError(msg);
+    else console.error(`\n  ${msg}\n`);
+    process.exit(1);
+  }
+
+  const maxBodySizeMb = maxBodyStr === null ? undefined : parseMaxBody(maxBodyStr, json);
+
+  /** @type {Record<string, unknown>} */
+  const body = { subdomain, port, agentLabel };
+  if (description) body.description = description;
+  if (accessMode) body.accessMode = accessMode;
+  if (maxBodySizeMb !== undefined) body.maxBodySizeMb = maxBodySizeMb;
+
+  if (!json) process.stderr.write(`  Creating tunnel ${chalk.cyan(subdomain)} \u2192 :${port}...`);
+
+  try {
+    const { tunnel } = await panelRequest('POST', '/api/tunnels', body);
+
+    if (json) {
+      emitComplete({ tunnel });
+    } else {
+      console.log(` ${chalk.green('ok')}`);
+      console.log(`  FQDN:  ${chalk.cyan(tunnel.fqdn)}`);
+      console.log(`  ID:    ${chalk.dim(tunnel.id)}`);
+      console.log(`  Agent: ${tunnel.agentLabel}`);
+      console.log(chalk.dim(`  ${tunnel.agentLabel} starts carrying it within 30 seconds.`));
+      console.log('');
+    }
+  } catch (err) {
+    if (json) emitError(err.message);
+    else {
+      console.log(` ${chalk.red('failed')}`);
+      console.error(`  ${chalk.red(err.message)}\n`);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * @param {string | undefined} id
+ * @param {{ json: boolean }} options
+ */
+async function deleteTunnel(id, { json }) {
+  if (!id) {
+    const msg = 'Usage: lamaste-server tunnels delete <id>';
+    if (json) emitError(msg);
+    else console.error(`\n  ${msg}\n`);
+    process.exit(1);
+  }
+
+  if (!json) process.stderr.write(`  Deleting tunnel ${chalk.dim(id)}...`);
+
+  try {
+    await panelRequest('DELETE', `/api/tunnels/${id}`);
+    if (json) {
+      emitComplete({ id, deleted: true });
+    } else {
+      console.log(` ${chalk.green('ok')}\n`);
+    }
+  } catch (err) {
+    if (json) emitError(err.message);
+    else {
+      console.log(` ${chalk.red('failed')}`);
+      console.error(`  ${chalk.red(err.message)}\n`);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * @param {string[]} args
+ * @param {{ json: boolean }} options
+ */
+async function toggleTunnel(args, { json }) {
+  const id = args[0];
+  const enable = args.includes('--enable');
+  const disable = args.includes('--disable');
+
+  if (!id || (!enable && !disable)) {
+    const msg = 'Usage: lamaste-server tunnels toggle <id> --enable|--disable';
+    if (json) emitError(msg);
+    else console.error(`\n  ${msg}\n`);
+    process.exit(1);
+  }
+
+  const enabled = enable;
+
+  if (!json) {
+    const action = enabled ? 'Enabling' : 'Disabling';
+    process.stderr.write(`  ${action} tunnel ${chalk.dim(id)}...`);
+  }
+
+  try {
+    const { tunnel } = await panelRequest('PATCH', `/api/tunnels/${id}`, { enabled });
+    if (json) {
+      emitComplete({ id, enabled, tunnel });
+    } else {
+      console.log(` ${chalk.green('ok')}\n`);
+    }
+  } catch (err) {
+    if (json) emitError(err.message);
+    else {
+      console.log(` ${chalk.red('failed')}`);
+      console.error(`  ${chalk.red(err.message)}\n`);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * @param {string[]} args
+ * @param {{ json: boolean }} options
+ */
+async function assignTunnel(args, { json }) {
+  const id = args[0];
+  const agentLabel = getArg(args, 'agent');
+
+  if (!id || !agentLabel) {
+    const msg = 'Usage: lamaste-server tunnels assign <id> --agent <label>';
+    if (json) emitError(msg);
+    else console.error(`\n  ${msg}\n`);
+    process.exit(1);
+  }
+
+  if (!json) process.stderr.write(`  Assigning tunnel ${chalk.dim(id)} to ${agentLabel}...`);
+
+  try {
+    const { tunnel } = await panelRequest('PATCH', `/api/tunnels/${id}`, { agentLabel });
+    if (json) {
+      emitComplete({ id, tunnel });
+    } else {
+      console.log(` ${chalk.green('ok')}`);
+      console.log(
+        chalk.dim(`  ${agentLabel} and the previous agent pick up the change within 30 seconds.\n`),
+      );
+    }
+  } catch (err) {
+    if (json) emitError(err.message);
+    else {
+      console.log(` ${chalk.red('failed')}`);
+      console.error(`  ${chalk.red(err.message)}\n`);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * @param {string[]} args
+ * @param {{ json: boolean }} options
+ */
+async function configureTunnel(args, { json }) {
+  const id = args[0];
+  const accessMode = getArg(args, 'access-mode');
+  const maxBodyStr = getArg(args, 'max-body-mb');
+
+  if (!id || (accessMode === null && maxBodyStr === null)) {
+    const msg =
+      'Usage: lamaste-server tunnels configure <id> [--access-mode <mode>] [--max-body-mb <n>]';
+    if (json) emitError(msg);
+    else console.error(`\n  ${msg}\n`);
+    process.exit(1);
+  }
+  if (accessMode !== null && !['public', 'authenticated', 'restricted'].includes(accessMode)) {
+    const msg = 'Error: --access-mode must be public, authenticated, or restricted';
+    if (json) emitError(msg);
+    else console.error(`\n  ${msg}\n`);
+    process.exit(1);
+  }
+
+  /** @type {Record<string, unknown>} */
+  const body = {};
+  if (accessMode !== null) body.accessMode = accessMode;
+  if (maxBodyStr !== null) body.maxBodySizeMb = parseMaxBody(maxBodyStr, json);
+
+  if (!json) process.stderr.write(`  Reconfiguring tunnel ${chalk.dim(id)}...`);
+
+  try {
+    const { tunnel } = await panelRequest('PATCH', `/api/tunnels/${id}`, body);
+    if (json) {
+      emitComplete({ id, tunnel });
+    } else {
+      console.log(` ${chalk.green('ok')}`);
+      console.log(`  Access:     ${tunnel.accessMode}`);
+      console.log(`  Body limit: ${tunnel.maxBodySizeMb} MiB\n`);
+    }
+  } catch (err) {
+    if (json) emitError(err.message);
+    else {
+      console.log(` ${chalk.red('failed')}`);
+      console.error(`  ${chalk.red(err.message)}\n`);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * @param {string} value
+ * @param {boolean} json
+ * @returns {number}
+ */
+function parseMaxBody(value, json) {
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 1 || n > 10240) {
+    const msg = 'Error: --max-body-mb must be an integer from 1 to 10240';
+    if (json) emitError(msg);
+    else console.error(`\n  ${msg}\n`);
+    process.exit(1);
+  }
+  return n;
+}
+
+/**
+ * @param {string[]} args
+ * @param {string} name
+ * @returns {string | null}
+ */
+function getArg(args, name) {
+  const idx = args.indexOf(`--${name}`);
+  if (idx === -1 || idx + 1 >= args.length) return null;
+  return args[idx + 1];
+}

package/vendor/server/src/commands/uninstall.js

@@ -0,0 +1,326 @@
+/**
+ * lamaste-server uninstall — Full server teardown.
+ *
+ * Cleanup order (reverse of installation):
+ *
+ * 1. Stop and disable services (panel, gatekeeper)
+ * 2. Remove systemd service files
+ * 3. Remove nginx configurations (vhosts, sites)
+ * 4. Reload nginx (falls back to default config)
+ * 5. Remove certbot certificates
+ * 6. Remove Authelia configuration
+ * 7. Remove Lamaste data directory (/etc/lamalibre/lamaste)
+ * 8. Remove installed npm packages
+ * 9. Remove lamaste system user
+ *
+ * Requires root access. Interactive confirmation unless --force is passed.
+ */
+
+import { readFile } from 'node:fs/promises';
+import { createInterface } from 'node:readline';
+import chalk from 'chalk';
+import { execa } from 'execa';
+import { CONFIG_PATH, STATE_DIR, PANEL_SERVICE, GATEKEEPER_SERVICE } from '../config.js';
+import { emitStep, emitError, emitComplete } from '../ndjson.js';
+
+/**
+ * @param {string[]} args
+ * @param {{ json: boolean }} options
+ */
+export async function runUninstall(args, { json }) {
+  // Verify running as root
+  if (process.getuid && process.getuid() !== 0) {
+    const msg = 'lamaste-server uninstall must be run as root.';
+    if (json) emitError(msg);
+    else {
+      console.error(`\n  Error: ${msg}`);
+      console.error('  Usage: sudo lamaste-server uninstall\n');
+    }
+    process.exit(1);
+  }
+
+  const force = args.includes('--force');
+
+  // Read config to get domain info for display
+  let config = null;
+  try {
+    const raw = await readFile(CONFIG_PATH, 'utf-8');
+    config = JSON.parse(raw);
+  } catch {
+    // Config may not exist
+  }
+
+  const domain = config?.domain || 'unknown';
+
+  if (!force && !json) {
+    console.log('');
+    console.log(chalk.bold.red('  WARNING: This will completely remove Lamaste from this server.'));
+    console.log('');
+    console.log(`  Domain:   ${chalk.cyan(String(domain))}`);
+    console.log(`  Data dir: ${chalk.dim(STATE_DIR)}`);
+    console.log('');
+    console.log('  This action will:');
+    console.log('    - Stop and remove all Lamaste services');
+    console.log('    - Remove all nginx tunnel/site configurations');
+    console.log("    - Remove all certificates (mTLS and Let's Encrypt)");
+    console.log('    - Remove Authelia configuration');
+    console.log('    - Delete all Lamaste data');
+    console.log('');
+
+    const confirmed = await promptConfirm('  Type "uninstall" to confirm: ', 'uninstall');
+    if (!confirmed) {
+      console.log('\n  Aborted.\n');
+      process.exit(0);
+    }
+    console.log('');
+  }
+
+  const steps = [
+    { name: 'stop-services', label: 'Stopping services', fn: stopServices },
+    { name: 'remove-services', label: 'Removing service files', fn: removeServices },
+    { name: 'remove-nginx', label: 'Removing nginx configurations', fn: removeNginxConfigs },
+    { name: 'reload-nginx', label: 'Reloading nginx', fn: reloadNginx },
+    { name: 'remove-certbot', label: 'Removing certbot certificates', fn: removeCertbotCerts },
+    { name: 'remove-authelia', label: 'Removing Authelia', fn: removeAuthelia },
+    { name: 'remove-data', label: 'Removing Lamaste data', fn: removeData },
+    { name: 'remove-packages', label: 'Removing npm packages', fn: removePackages },
+    { name: 'remove-user', label: 'Removing lamaste user', fn: removeUser },
+    {
+      name: 'remove-authelia-user',
+      label: 'Removing lamaste-authelia user',
+      fn: removeAutheliaUser,
+    },
+  ];
+
+  for (const step of steps) {
+    if (json) emitStep(step.name, 'running', step.label);
+    else process.stderr.write(`  ${step.label}...`);
+
+    try {
+      await step.fn(config);
+      if (json) emitStep(step.name, 'complete');
+      else console.log(` ${chalk.green('ok')}`);
+    } catch (err) {
+      // Non-fatal: log and continue with remaining steps
+      const msg = err.message || String(err);
+      if (json) emitStep(step.name, 'failed', msg);
+      else console.log(` ${chalk.yellow('skipped')} ${chalk.dim(`(${msg})`)}`);
+    }
+  }
+
+  if (json) {
+    emitComplete({ uninstalled: true });
+  } else {
+    console.log('');
+    console.log(chalk.green('  Lamaste has been removed from this server.'));
+    console.log('');
+  }
+}
+
+async function stopServices() {
+  for (const service of [PANEL_SERVICE, GATEKEEPER_SERVICE, 'chisel']) {
+    try {
+      await execa('systemctl', ['stop', service], { timeout: 15000 });
+    } catch {
+      // Service may not be running
+    }
+    try {
+      await execa('systemctl', ['disable', service], { timeout: 10000 });
+    } catch {
+      // Service may not be enabled
+    }
+  }
+}
+
+async function removeServices() {
+  const serviceFiles = [
+    `/etc/systemd/system/${PANEL_SERVICE}.service`,
+    `/etc/systemd/system/${GATEKEEPER_SERVICE}.service`,
+    '/etc/systemd/system/chisel.service',
+    '/etc/systemd/system/authelia.service',
+  ];
+
+  for (const file of serviceFiles) {
+    await execa('rm', ['-f', file]).catch(() => {});
+  }
+
+  await execa('systemctl', ['daemon-reload']).catch(() => {});
+
+  // Remove sudoers file and the root-owned wrappers it referenced
+  await execa('rm', ['-f', '/etc/sudoers.d/lamaste']).catch(() => {});
+  await execa('rm', [
+    '-f',
+    '/usr/local/sbin/lamaste-priv',
+    '/usr/local/sbin/lamaste-certbot',
+    '/usr/local/sbin/lamaste-cert-info',
+    // installed by versions before 4.0
+    '/usr/local/sbin/lamaste-sign-csr',
+    '/usr/local/sbin/lamaste-pki-rename',
+  ]).catch(() => {});
+}
+
+/**
+ * @param {Record<string, unknown> | null} _config
+ */
+async function removeNginxConfigs(_config) {
+  // Remove lamaste-specific sites
+  const patterns = [
+    '/etc/nginx/sites-enabled/lamalibre-lamaste-*',
+    '/etc/nginx/sites-available/lamalibre-lamaste-*',
+    '/etc/nginx/snippets/lamalibre-lamaste-*',
+  ];
+
+  for (const pattern of patterns) {
+    // Use shell glob expansion safely via rm
+    await execa('sh', ['-c', `rm -f ${pattern}`]).catch(() => {});
+  }
+
+  // Remove any tunnel/site vhosts (they use the subdomain as filename)
+  // Read tunnels and sites to identify their vhost files
+  try {
+    const tunnelsRaw = await readFile(`${STATE_DIR}/tunnels.json`, 'utf-8');
+    const tunnels = JSON.parse(tunnelsRaw);
+    if (Array.isArray(tunnels)) {
+      for (const t of tunnels) {
+        if (t.subdomain) {
+          await execa('rm', [
+            '-f',
+            `/etc/nginx/sites-enabled/${t.subdomain}`,
+            `/etc/nginx/sites-available/${t.subdomain}`,
+          ]).catch(() => {});
+        }
+      }
+    }
+  } catch {
+    // No tunnels file
+  }
+
+  try {
+    const sitesRaw = await readFile(`${STATE_DIR}/sites.json`, 'utf-8');
+    const sites = JSON.parse(sitesRaw);
+    if (Array.isArray(sites)) {
+      for (const s of sites) {
+        if (s.id) {
+          await execa('rm', [
+            '-f',
+            `/etc/nginx/sites-enabled/site-${s.id}`,
+            `/etc/nginx/sites-available/site-${s.id}`,
+          ]).catch(() => {});
+        }
+      }
+    }
+  } catch {
+    // No sites file
+  }
+}
+
+async function reloadNginx() {
+  await execa('nginx', ['-t'], { timeout: 10000 });
+  await execa('systemctl', ['reload', 'nginx'], { timeout: 10000 });
+}
+
+async function removeCertbotCerts() {
+  // List all certbot certificates and delete lamaste-related ones
+  try {
+    const { stdout } = await execa('certbot', ['certificates', '--non-interactive'], {
+      timeout: 30000,
+    });
+
+    const certNames = [];
+    for (const match of stdout.matchAll(/Certificate Name:\s+(.+)/g)) {
+      certNames.push(match[1].trim());
+    }
+
+    for (const name of certNames) {
+      await execa('certbot', ['delete', '--non-interactive', '--cert-name', name], {
+        timeout: 15000,
+      }).catch(() => {});
+    }
+  } catch {
+    // certbot may not be installed
+  }
+}
+
+async function removeAuthelia() {
+  // Stop and disable authelia
+  await execa('systemctl', ['stop', 'authelia']).catch(() => {});
+  await execa('systemctl', ['disable', 'authelia']).catch(() => {});
+
+  // Remove its configuration, database and log, and the binary
+  // create-lamaste installed (the pinned release, at /usr/local/bin).
+  await execa('rm', ['-rf', '/etc/authelia', '/var/log/authelia']).catch(() => {});
+  await execa('rm', ['-f', '/usr/local/bin/authelia']).catch(() => {});
+}
+
+async function removeData() {
+  // Remove the entire lamaste data directory
+  await execa('rm', ['-rf', STATE_DIR]);
+
+  // Remove site content directories
+  await execa('rm', ['-rf', '/var/www/lamaste']).catch(() => {});
+
+  // Remove chisel binary
+  await execa('rm', ['-f', '/usr/local/bin/chisel']).catch(() => {});
+
+  // Remove the lamaste-reset-admin symlink (legacy)
+  await execa('rm', ['-f', '/usr/local/bin/lamaste-reset-admin']).catch(() => {});
+}
+
+async function removePackages() {
+  // Locate and remove globally installed lamaste packages
+  try {
+    const { stdout } = await execa('npm', ['ls', '-g', '--depth=0', '--json'], {
+      timeout: 15000,
+    });
+    const globalPkgs = JSON.parse(stdout);
+    const deps = globalPkgs.dependencies || {};
+
+    for (const [name] of Object.entries(deps)) {
+      if (name.startsWith('@lamalibre/')) {
+        await execa('npm', ['uninstall', '-g', name], { timeout: 30000 }).catch(() => {});
+      }
+    }
+  } catch {
+    // Global packages listing may fail
+  }
+
+  // Remove the panel server installation directory
+  await execa('rm', ['-rf', '/opt/lamalibre/lamaste']).catch(() => {});
+}
+
+async function removeUser() {
+  // Check if lamaste user exists
+  try {
+    await execa('id', ['lamaste']);
+  } catch {
+    return; // User does not exist
+  }
+
+  // Remove the user and its home directory
+  await execa('userdel', ['-r', 'lamaste']).catch(() => {});
+
+  // Remove groups if they still exist
+  await execa('groupdel', ['lamaste']).catch(() => {});
+  await execa('groupdel', ['lamaste-chisel']).catch(() => {});
+}
+
+async function removeAutheliaUser() {
+  await execa('userdel', ['lamaste-authelia']).catch(() => {});
+  await execa('groupdel', ['lamaste-authelia']).catch(() => {});
+}
+
+/**
+ * Prompt the user for confirmation.
+ * @param {string} prompt
+ * @param {string} expected  The exact text the user must type
+ * @returns {Promise<boolean>}
+ */
+function promptConfirm(prompt, expected) {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(answer.trim() === expected);
+    });
+  });
+}