@lamalibre/create-lamaste 4.0.0

package/vendor/server/src/config.js

@@ -0,0 +1,38 @@
+/**
+ * Server configuration helpers.
+ *
+ * Reads panel.json and provides common paths used by all commands.
+ */
+
+import { readFile } from 'node:fs/promises';
+
+/** Default paths used on the server. */
+export const CONFIG_PATH =
+  process.env.LAMALIBRE_LAMASTE_CONFIG || '/etc/lamalibre/lamaste/panel.json';
+export const STATE_DIR = process.env.LAMALIBRE_LAMASTE_DATA_DIR || '/etc/lamalibre/lamaste';
+export const PKI_DIR = process.env.LAMALIBRE_LAMASTE_PKI_DIR || '/etc/lamalibre/lamaste/pki';
+
+/** Systemd service names. */
+export const PANEL_SERVICE = 'lamalibre-lamaste-serverd';
+export const GATEKEEPER_SERVICE = 'lamalibre-lamaste-gatekeeper';
+
+/**
+ * Read and parse panel.json.
+ * @returns {Promise<Record<string, unknown>>}
+ */
+export async function readConfig() {
+  const raw = await readFile(CONFIG_PATH, 'utf-8');
+  return JSON.parse(raw);
+}
+
+/**
+ * Read panel.json, returning null on error instead of throwing.
+ * @returns {Promise<Record<string, unknown> | null>}
+ */
+export async function readConfigSafe() {
+  try {
+    return await readConfig();
+  } catch {
+    return null;
+  }
+}

package/vendor/server/src/exec.js

@@ -0,0 +1,26 @@
+/**
+ * Shared exec helper that wraps execa for use by core library functions.
+ *
+ * The core library (@lamalibre/lamaste/server) accepts an ExecFn dependency.
+ * This module provides the concrete implementation backed by execa.
+ */
+
+import { execa } from 'execa';
+
+/**
+ * Execute a command with array arguments via execa.
+ * Conforms to the ExecFn interface expected by @lamalibre/lamaste/server.
+ *
+ * @param {string} file
+ * @param {string[]} args
+ * @param {{ cwd?: string, timeout?: number, input?: string }} [options]
+ * @returns {Promise<{ stdout: string, stderr: string }>}
+ */
+export async function exec(file, args, options) {
+  const result = await execa(file, args, {
+    cwd: options?.cwd,
+    timeout: options?.timeout,
+    input: options?.input,
+  });
+  return { stdout: result.stdout, stderr: result.stderr };
+}

package/vendor/server/src/logger.js

@@ -0,0 +1,39 @@
+/**
+ * CLI logger that satisfies the PluginLogger / TunnelLogger / SiteLogger
+ * interfaces expected by @lamalibre/lamaste/server.
+ *
+ * In normal mode, logs are written to stderr with chalk formatting.
+ * In --json mode, logs are suppressed (output goes through ndjson.js).
+ */
+
+import chalk from 'chalk';
+
+/**
+ * Create a logger for CLI command use.
+ * @param {{ json: boolean }} options
+ * @returns {{ info: Function, warn: Function, error: Function }}
+ */
+export function createLogger({ json }) {
+  if (json) {
+    return {
+      info() {},
+      warn() {},
+      error() {},
+    };
+  }
+
+  return {
+    /** @param {Record<string, unknown>} _obj @param {string} [msg] */
+    info(_obj, msg) {
+      if (msg) process.stderr.write(`  ${chalk.dim(msg)}\n`);
+    },
+    /** @param {Record<string, unknown>} _obj @param {string} [msg] */
+    warn(_obj, msg) {
+      if (msg) process.stderr.write(`  ${chalk.yellow('warn:')} ${msg}\n`);
+    },
+    /** @param {Record<string, unknown>} _obj @param {string} [msg] */
+    error(_obj, msg) {
+      if (msg) process.stderr.write(`  ${chalk.red('error:')} ${msg}\n`);
+    },
+  };
+}

package/vendor/server/src/ndjson.js

@@ -0,0 +1,56 @@
+/**
+ * NDJSON output helper for --json mode.
+ *
+ * When --json is enabled, all output goes through this module as
+ * newline-delimited JSON on stdout. This is consumed by the desktop
+ * app (Tauri) and automation scripts.
+ */
+
+/**
+ * Write a single NDJSON event line to stdout.
+ * @param {Record<string, unknown>} event
+ */
+export function emit(event) {
+  process.stdout.write(JSON.stringify(event) + '\n');
+}
+
+/**
+ * Emit a step progress event.
+ * @param {string} step
+ * @param {'running' | 'complete' | 'skipped' | 'failed'} status
+ * @param {string} [detail]
+ */
+export function emitStep(step, status, detail) {
+  /** @type {Record<string, unknown>} */
+  const event = { event: 'step', step, status };
+  if (detail) event.detail = detail;
+  emit(event);
+}
+
+/**
+ * Emit an error event.
+ * @param {string} message
+ * @param {boolean} [recoverable]
+ */
+export function emitError(message, recoverable = false) {
+  emit({ event: 'error', message, recoverable });
+}
+
+/**
+ * Emit a completion event with result data.
+ * @param {Record<string, unknown>} data
+ */
+export function emitComplete(data) {
+  emit({ event: 'complete', ...data });
+}
+
+/**
+ * Emit a log event — non-step progress messages that consumers (desktop app,
+ * automation) can surface alongside step progress.
+ * @param {'debug' | 'info' | 'warn' | 'error'} level
+ * @param {string} message
+ * @param {Record<string, unknown>} [data]
+ */
+export function emitLog(level, message, data) {
+  emit({ event: 'log', level, message, ...(data ? { data } : {}) });
+}

package/vendor/server/src/panel-api.js

@@ -0,0 +1,85 @@
+/**
+ * Panel REST API client for localhost calls.
+ *
+ * Used by tunnel/site commands that need the full dependency stack
+ * (nginx, certbot, chisel) which lives in the running panel server.
+ * Authenticates via the admin mTLS client certificate.
+ */
+
+import { readFile, writeFile, unlink } from 'node:fs/promises';
+import crypto from 'node:crypto';
+import { execa } from 'execa';
+import { PKI_DIR } from './config.js';
+
+const PANEL_URL = 'https://127.0.0.1:9292';
+
+/**
+ * Make an authenticated API request to the local panel server.
+ *
+ * Uses curl with the admin client certificate (mTLS) and a temporary
+ * config file for the P12 password (never in process args).
+ *
+ * @param {string} method
+ * @param {string} path  e.g. '/api/tunnels'
+ * @param {Record<string, unknown> | null} [body]
+ * @returns {Promise<Record<string, unknown>>}
+ */
+export async function panelRequest(method, path, body = null) {
+  const p12Path = `${PKI_DIR}/client.p12`;
+
+  // Read p12 password from the stored file
+  let p12Password;
+  try {
+    p12Password = (await readFile(`${PKI_DIR}/.p12-password`, 'utf-8')).trim();
+  } catch {
+    throw new Error(
+      'Cannot read P12 password. Ensure the server is properly installed and /etc/lamalibre/lamaste/pki/.p12-password exists.',
+    );
+  }
+
+  // Write password to a temporary config file (never in process args)
+  const tmpConfigPath = `/tmp/lamalibre-lamaste-curl-${crypto.randomBytes(8).toString('hex')}`;
+  try {
+    await writeFile(tmpConfigPath, `--pass "${p12Password}"\n`, { mode: 0o600 });
+
+    const curlArgs = [
+      '-K',
+      tmpConfigPath,
+      '--cert-type',
+      'P12',
+      '--cert',
+      p12Path,
+      '-k', // Server uses self-signed cert on localhost
+      '-s', // Silent
+      '-S', // Show errors
+      '-X',
+      method,
+      '-H',
+      'Content-Type: application/json',
+    ];
+
+    if (body) {
+      curlArgs.push('-d', JSON.stringify(body));
+    }
+
+    // Append the HTTP status on its own line so an error response is not
+    // mistaken for a result — the panel answers errors with a JSON body.
+    curlArgs.push('-w', '\n%{http_code}', `${PANEL_URL}${path}`);
+
+    const { stdout } = await execa('curl', curlArgs, { timeout: 30000 });
+
+    const split = stdout.lastIndexOf('\n');
+    const payload = stdout.slice(0, split).trim();
+    const status = Number(stdout.slice(split + 1).trim());
+    const parsed = payload ? JSON.parse(payload) : {};
+
+    if (!Number.isInteger(status) || status >= 400) {
+      const reason = [parsed.error, parsed.details].filter(Boolean).join(': ');
+      throw new Error(`${method} ${path} failed (HTTP ${status})${reason ? `: ${reason}` : ''}`);
+    }
+
+    return parsed;
+  } finally {
+    await unlink(tmpConfigPath).catch(() => {});
+  }
+}

package/vendor/server/src/state.js

@@ -0,0 +1,45 @@
+/**
+ * Direct state file readers for server CLI.
+ *
+ * Used by list/read commands that only need to read the JSON state files.
+ * Mutation commands use the panel REST API instead, since mutations require
+ * the full dependency stack (nginx, certbot, chisel).
+ */
+
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { STATE_DIR } from './config.js';
+
+/**
+ * Read and parse a JSON state file, returning a default value on ENOENT.
+ * @param {string} filename
+ * @param {unknown} defaultValue
+ * @returns {Promise<unknown>}
+ */
+async function readStateFile(filename, defaultValue) {
+  try {
+    const raw = await readFile(path.join(STATE_DIR, filename), 'utf-8');
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === 'ENOENT') return defaultValue;
+    throw new Error(`Failed to read ${filename}: ${err.message}`);
+  }
+}
+
+/**
+ * Read the tunnels array from tunnels.json.
+ * @returns {Promise<Array<Record<string, unknown>>>}
+ */
+export async function readTunnels() {
+  const data = await readStateFile('tunnels.json', []);
+  return Array.isArray(data) ? data : [];
+}
+
+/**
+ * Read the sites array from sites.json.
+ * @returns {Promise<Array<Record<string, unknown>>>}
+ */
+export async function readSites() {
+  const data = await readStateFile('sites.json', []);
+  return Array.isArray(data) ? data : [];
+}