@lamalibre/create-lamaste 4.0.0

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

@@ -0,0 +1,257 @@
+/**
+ * lamaste-server sites — Manage static sites.
+ *
+ * Subcommands:
+ *   list                            List managed sites
+ *   create --name <n> [--type <t>]  Create a site
+ *   delete <id>                     Delete a site by ID
+ *   aliases <id> --set <a,b|"">     Replace a custom site's redirect aliases
+ *
+ * List reads directly from the state file.
+ * Create/delete use the panel REST API (which has the full
+ * nginx/certbot/directory dependency stack).
+ */
+
+import chalk from 'chalk';
+import { readSites } 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 runSites(args, { json }) {
+  const sub = args[0];
+
+  switch (sub) {
+    case 'list':
+      return listSites({ json });
+    case 'create':
+      return createSite(args.slice(1), { json });
+    case 'delete':
+      return deleteSite(args[1], { json });
+    case 'aliases':
+      return setAliases(args.slice(1), { json });
+    default:
+      printSiteUsage();
+      process.exit(sub ? 1 : 0);
+  }
+}
+
+function printSiteUsage() {
+  const b = chalk.bold;
+  const c = chalk.cyan;
+  console.log(`
+${b('Usage:')} lamaste-server sites <subcommand>
+
+${b('Subcommands:')}
+  ${c('list')}                                  List managed sites
+  ${c('create')} --name <n> [options]            Create a site
+  ${c('delete')} <id>                            Delete a site by ID
+  ${c('aliases')} <id> --set <a,b>               Replace redirect aliases (--set "" clears)
+
+${b('Create options:')}
+  --name <name>         Site name (required)
+  --type <type>         Site type: managed (default) or custom
+  --custom-domain <d>   Custom domain (required if type is custom)
+  --aliases <a,b>       Hostnames that redirect to the custom domain (e.g. www.<domain>)
+  --spa                 Enable SPA mode (single-page application routing)
+  --authelia            Enable Authelia protection
+`);
+}
+
+/**
+ * @param {{ json: boolean }} options
+ */
+async function listSites({ json }) {
+  const sites = await readSites();
+
+  if (json) {
+    emit({ sites });
+    return;
+  }
+
+  if (sites.length === 0) {
+    console.log('\n  No sites configured.\n');
+    return;
+  }
+
+  const b = chalk.bold;
+  const c = chalk.cyan;
+  const g = chalk.green;
+  const y = chalk.yellow;
+  const d = chalk.dim;
+
+  console.log('');
+  console.log(b('  Static Sites'));
+  console.log(d('  ' + '\u2500'.repeat(50)));
+
+  for (const s of sites) {
+    const dnsStatus = s.dnsVerified ? g('verified') : y('pending DNS');
+    const certStatus = s.certIssued ? g('cert issued') : y('no cert');
+    const spaTag = s.spaMode ? d('[SPA]') : '';
+    const authTag = s.autheliaProtected ? d('[protected]') : '';
+
+    console.log(
+      `  ${c(s.name)}  ${d(s.fqdn)}  ${s.type}  ${dnsStatus}  ${certStatus} ${spaTag} ${authTag}`.trimEnd(),
+    );
+    console.log(`    ${d(`id: ${s.id}`)}`);
+  }
+  console.log('');
+}
+
+/**
+ * @param {string[]} args
+ * @param {{ json: boolean }} options
+ */
+async function createSite(args, { json }) {
+  const name = getArg(args, 'name');
+  const type = getArg(args, 'type') || 'managed';
+  const customDomain = getArg(args, 'custom-domain') || undefined;
+  const aliasArg = getArg(args, 'aliases');
+  const spaMode = args.includes('--spa');
+  const autheliaProtected = args.includes('--authelia');
+
+  if (!name) {
+    const msg = 'Error: --name is required';
+    if (json) emitError(msg);
+    else console.error(`\n  ${msg}\n`);
+    process.exit(1);
+  }
+
+  if (type !== 'managed' && type !== 'custom') {
+    const msg = 'Error: --type must be managed or custom';
+    if (json) emitError(msg);
+    else console.error(`\n  ${msg}\n`);
+    process.exit(1);
+  }
+
+  if (type === 'custom' && !customDomain) {
+    const msg = 'Error: --custom-domain is required for custom type sites';
+    if (json) emitError(msg);
+    else console.error(`\n  ${msg}\n`);
+    process.exit(1);
+  }
+
+  /** @type {Record<string, unknown>} */
+  const body = { name, type, spaMode, autheliaProtected };
+  if (customDomain) body.customDomain = customDomain;
+  if (aliasArg) body.aliases = splitAliases(aliasArg);
+
+  if (!json) process.stderr.write(`  Creating site ${chalk.cyan(name)}...`);
+
+  try {
+    const result = await panelRequest('POST', '/api/sites', body);
+
+    if (json) {
+      emitComplete({ site: result.site || result });
+    } else {
+      console.log(` ${chalk.green('ok')}`);
+      const site = result.site || result;
+      console.log(`  FQDN: ${chalk.cyan(String(site.fqdn || name))}`);
+      console.log(`  ID:   ${chalk.dim(String(site.id || 'unknown'))}`);
+      if (result.message) {
+        console.log(`  ${chalk.dim(String(result.message))}`);
+      }
+      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 deleteSite(id, { json }) {
+  if (!id) {
+    const msg = 'Usage: lamaste-server sites delete <id>';
+    if (json) emitError(msg);
+    else console.error(`\n  ${msg}\n`);
+    process.exit(1);
+  }
+
+  if (!json) process.stderr.write(`  Deleting site ${chalk.dim(id)}...`);
+
+  try {
+    await panelRequest('DELETE', `/api/sites/${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 {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];
+}
+
+/**
+ * @param {string} value
+ * @returns {string[]}
+ */
+function splitAliases(value) {
+  return value
+    .split(',')
+    .map((a) => a.trim().toLowerCase())
+    .filter(Boolean);
+}
+
+/**
+ * @param {string[]} args
+ * @param {{ json: boolean }} options
+ */
+async function setAliases(args, { json }) {
+  const id = args[0];
+  const setIdx = args.indexOf('--set');
+  if (!id || setIdx === -1 || setIdx + 1 >= args.length) {
+    const msg = 'Usage: lamaste-server sites aliases <id> --set <a,b>  (--set "" clears)';
+    if (json) emitError(msg);
+    else console.error(`\n  ${msg}\n`);
+    process.exit(1);
+  }
+  const aliases = splitAliases(args[setIdx + 1]);
+
+  if (!json) process.stderr.write(`  Updating aliases for ${chalk.dim(id)}...`);
+
+  try {
+    const result = await panelRequest('PATCH', `/api/sites/${id}`, { aliases });
+    if (json) {
+      emitComplete({ site: result.site, ...(result.warning ? { warning: result.warning } : {}) });
+    } else {
+      console.log(` ${chalk.green('ok')}`);
+      const list = result.site?.aliases ?? [];
+      console.log(`  Aliases: ${list.length > 0 ? list.join(', ') : chalk.dim('none')}\n`);
+      if (result.warning) console.log(`  ${chalk.yellow(result.warning)}\n`);
+    }
+  } catch (err) {
+    if (json) emitError(err.message);
+    else {
+      console.log(` ${chalk.red('failed')}`);
+      console.error(`  ${chalk.red(err.message)}\n`);
+    }
+    process.exit(1);
+  }
+}

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

@@ -0,0 +1,158 @@
+/**
+ * lamaste-server status — Server health, uptime, resource usage.
+ *
+ * Reads systemctl status, panel.json config, and cert expiry info.
+ */
+
+import chalk from 'chalk';
+import { execa } from 'execa';
+import { readConfigSafe, PANEL_SERVICE, GATEKEEPER_SERVICE, PKI_DIR } from '../config.js';
+import { getMtlsCerts } from '@lamalibre/lamaste/server';
+import { exec } from '../exec.js';
+import { emit } from '../ndjson.js';
+
+/**
+ * @param {{ json: boolean }} options
+ */
+export async function runStatus({ json }) {
+  const config = await readConfigSafe();
+  const domain = config?.domain ?? null;
+
+  // Collect service statuses
+  const panelStatus = await getServiceStatus(PANEL_SERVICE);
+  const gatekeeperStatus = await getServiceStatus(GATEKEEPER_SERVICE);
+  const nginxStatus = await getServiceStatus('nginx');
+  const autheliaStatus = await getServiceStatus('authelia');
+
+  // Collect cert info
+  let certs = [];
+  try {
+    certs = await getMtlsCerts(PKI_DIR, exec);
+  } catch {
+    // PKI dir may not be readable
+  }
+
+  // Collect system info
+  const uptime = await getUptime();
+  const memory = await getMemoryUsage();
+
+  if (json) {
+    emit({
+      domain,
+      services: {
+        panel: panelStatus,
+        gatekeeper: gatekeeperStatus,
+        nginx: nginxStatus,
+        authelia: autheliaStatus,
+      },
+      certificates: certs,
+      uptime,
+      memory,
+    });
+    return;
+  }
+
+  const b = chalk.bold;
+  const c = chalk.cyan;
+  const g = chalk.green;
+  const r = chalk.red;
+  const d = chalk.dim;
+  const y = chalk.yellow;
+
+  console.log('');
+  console.log(b('  Lamaste Server Status'));
+  console.log(d('  ' + '\u2500'.repeat(40)));
+
+  if (domain) {
+    console.log(`  ${b('Domain:')}     ${c(String(domain))}`);
+  }
+
+  if (uptime) {
+    console.log(`  ${b('Uptime:')}     ${d(uptime)}`);
+  }
+  if (memory) {
+    console.log(`  ${b('Memory:')}     ${d(memory)}`);
+  }
+
+  console.log('');
+  console.log(b('  Services'));
+  console.log(d('  ' + '\u2500'.repeat(40)));
+
+  printService('Panel', panelStatus, { b, g, r });
+  printService('Gatekeeper', gatekeeperStatus, { b, g, r });
+  printService('Nginx', nginxStatus, { b, g, r });
+  printService('Authelia', autheliaStatus, { b, g, r });
+
+  if (certs.length > 0) {
+    console.log('');
+    console.log(b('  Certificates'));
+    console.log(d('  ' + '\u2500'.repeat(40)));
+
+    for (const cert of certs) {
+      const label = cert.type === 'mtls-ca' ? 'CA' : 'Client';
+      const status = cert.expiringSoon ? y('expiring soon') : g('valid');
+      console.log(
+        `  ${b(label + ':')}  ${status}  ${d(`(expires in ${cert.daysUntilExpiry} days)`)}`,
+      );
+    }
+  }
+
+  console.log('');
+}
+
+/**
+ * @param {string} name
+ * @param {{ active: boolean, status: string }} info
+ * @param {Record<string, Function>} colors
+ */
+function printService(name, info, { b, g, r }) {
+  const pad = name.length < 12 ? ' '.repeat(12 - name.length) : ' ';
+  const statusText = info.active ? g('active') : r(info.status || 'inactive');
+  console.log(`  ${b(name + ':')}${pad}${statusText}`);
+}
+
+/**
+ * Get systemd service status.
+ * @param {string} service
+ * @returns {Promise<{ active: boolean, status: string }>}
+ */
+async function getServiceStatus(service) {
+  try {
+    const { stdout } = await execa('systemctl', ['is-active', service]);
+    const status = stdout.trim();
+    return { active: status === 'active', status };
+  } catch (err) {
+    const status = err?.stdout?.trim() || 'inactive';
+    return { active: false, status };
+  }
+}
+
+/**
+ * Get system uptime as a human-readable string.
+ * @returns {Promise<string | null>}
+ */
+async function getUptime() {
+  try {
+    const { stdout } = await execa('uptime', ['-p']);
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get memory usage summary.
+ * @returns {Promise<string | null>}
+ */
+async function getMemoryUsage() {
+  try {
+    const { stdout } = await execa('free', ['-h', '--si']);
+    const lines = stdout.trim().split('\n');
+    const memLine = lines.find((l) => l.startsWith('Mem:'));
+    if (!memLine) return null;
+    const parts = memLine.split(/\s+/);
+    return `${parts[2]} used / ${parts[1]} total`;
+  } catch {
+    return null;
+  }
+}