1483 lines
46 KiB
JavaScript
1483 lines
46 KiB
JavaScript
#!/usr/bin/env node
|
|
'use strict';
|
|
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
|
|
// =============================================================================
|
|
// Constants & Configuration
|
|
// =============================================================================
|
|
|
|
/**
|
|
* Ordered list of variable groups presented during the wizard flow.
|
|
*/
|
|
const GROUP_ORDER = [
|
|
'Core Settings',
|
|
'Database',
|
|
'Session',
|
|
'NVD API',
|
|
'Ivanti Integration',
|
|
'Atlas Integration',
|
|
'Jira Integration',
|
|
'CARD Integration',
|
|
'GitLab Integration',
|
|
'Frontend Settings'
|
|
];
|
|
|
|
/**
|
|
* One-line description per group (max 120 characters each).
|
|
*/
|
|
const GROUP_DESCRIPTIONS = {
|
|
'Core Settings': 'Server port, hostname, and CORS configuration',
|
|
'Database': 'PostgreSQL connection string for persistent storage',
|
|
'Session': 'Secret key for signing session cookies',
|
|
'NVD API': 'National Vulnerability Database API key for CVE lookups',
|
|
'Ivanti Integration': 'RiskSense platform credentials for vulnerability sync',
|
|
'Atlas Integration': 'Atlas InfoSec API for action plan management',
|
|
'Jira Integration': 'Jira Data Center for ticket creation and tracking',
|
|
'CARD Integration': 'CARD asset ownership API for host lookups',
|
|
'GitLab Integration': 'GitLab API for feedback submission (bug reports)',
|
|
'Frontend Settings': 'React app API endpoint configuration'
|
|
};
|
|
|
|
/**
|
|
* Groups that present a skip prompt before entering.
|
|
*/
|
|
const SKIPPABLE_GROUPS = [
|
|
'NVD API',
|
|
'Ivanti Integration',
|
|
'Atlas Integration',
|
|
'Jira Integration',
|
|
'CARD Integration',
|
|
'GitLab Integration'
|
|
];
|
|
|
|
/**
|
|
* Variables whose values are masked in display (passwords, secrets, API keys, tokens).
|
|
*/
|
|
const SENSITIVE_VARS = [
|
|
'SESSION_SECRET',
|
|
'NVD_API_KEY',
|
|
'IVANTI_API_KEY',
|
|
'ATLAS_API_PASS',
|
|
'JIRA_API_TOKEN',
|
|
'JIRA_PAT',
|
|
'CARD_API_PASS',
|
|
'GITLAB_PAT',
|
|
'DATABASE_URL'
|
|
];
|
|
|
|
/**
|
|
* Complete registry of all 32 managed environment variables with metadata.
|
|
* Each descriptor contains:
|
|
* name — environment variable name
|
|
* group — which GROUP_ORDER group it belongs to
|
|
* required — whether a non-empty value is mandatory
|
|
* default — factory default value (null if none; 'derived' handled at runtime)
|
|
* description — max 120 chars explaining what the variable controls
|
|
* docUrl — URL or instruction for obtaining the value (null if N/A)
|
|
* sensitive — whether to mask the value in display
|
|
* validator — name of validation function to apply (null if none)
|
|
*/
|
|
const VARIABLE_DESCRIPTORS = [
|
|
// --- Core Settings ---
|
|
{
|
|
name: 'PORT',
|
|
group: 'Core Settings',
|
|
required: true,
|
|
default: '3001',
|
|
description: 'TCP port the backend Express server listens on',
|
|
docUrl: null,
|
|
sensitive: false,
|
|
validator: 'validatePort'
|
|
},
|
|
{
|
|
name: 'API_HOST',
|
|
group: 'Core Settings',
|
|
required: true,
|
|
default: 'localhost',
|
|
description: 'Hostname or IP address the backend binds to',
|
|
docUrl: null,
|
|
sensitive: false,
|
|
validator: null
|
|
},
|
|
{
|
|
name: 'CORS_ORIGINS',
|
|
group: 'Core Settings',
|
|
required: false,
|
|
default: null, // derived from frontend port at runtime
|
|
description: 'Allowed CORS origins (only needed if frontend dev server runs on a separate port)',
|
|
docUrl: null,
|
|
sensitive: false,
|
|
validator: 'validateCorsOrigins'
|
|
},
|
|
|
|
// --- Database ---
|
|
{
|
|
name: 'DATABASE_URL',
|
|
group: 'Database',
|
|
required: true,
|
|
default: null, // derived from docker-compose.yml or fallback
|
|
description: 'PostgreSQL connection string (or "sqlite" for SQLite mode)',
|
|
docUrl: null,
|
|
sensitive: true,
|
|
validator: 'validateDatabaseUrl'
|
|
},
|
|
|
|
// --- Session ---
|
|
{
|
|
name: 'SESSION_SECRET',
|
|
group: 'Session',
|
|
required: true,
|
|
default: null,
|
|
description: 'Secret key for signing session cookies — generate with: openssl rand -base64 32',
|
|
docUrl: null,
|
|
sensitive: true,
|
|
validator: 'validateSessionSecret'
|
|
},
|
|
|
|
// --- NVD API ---
|
|
{
|
|
name: 'NVD_API_KEY',
|
|
group: 'NVD API',
|
|
required: false,
|
|
default: null,
|
|
description: 'API key to increase NVD rate limit from 5 to 50 requests per 30 seconds',
|
|
docUrl: 'https://nvd.nist.gov/developers/request-an-api-key',
|
|
sensitive: true,
|
|
validator: null
|
|
},
|
|
|
|
// --- Ivanti Integration ---
|
|
{
|
|
name: 'IVANTI_API_KEY',
|
|
group: 'Ivanti Integration',
|
|
required: false,
|
|
default: null,
|
|
description: 'RiskSense API key from your profile settings (does not expire like session cookies)',
|
|
docUrl: 'https://platform4.risksense.com — Profile > API Keys',
|
|
sensitive: true,
|
|
validator: null
|
|
},
|
|
{
|
|
name: 'IVANTI_CLIENT_ID',
|
|
group: 'Ivanti Integration',
|
|
required: false,
|
|
default: '1550',
|
|
description: 'RiskSense client/organization ID for API requests',
|
|
docUrl: 'https://platform4.risksense.com — visible in URL after login',
|
|
sensitive: false,
|
|
validator: null
|
|
},
|
|
{
|
|
name: 'IVANTI_FIRST_NAME',
|
|
group: 'Ivanti Integration',
|
|
required: false,
|
|
default: null,
|
|
description: 'First name of the service account user for Ivanti API authentication',
|
|
docUrl: null,
|
|
sensitive: false,
|
|
validator: null
|
|
},
|
|
{
|
|
name: 'IVANTI_LAST_NAME',
|
|
group: 'Ivanti Integration',
|
|
required: false,
|
|
default: null,
|
|
description: 'Last name of the service account user for Ivanti API authentication',
|
|
docUrl: null,
|
|
sensitive: false,
|
|
validator: null
|
|
},
|
|
{
|
|
name: 'IVANTI_BU_FILTER',
|
|
group: 'Ivanti Integration',
|
|
required: false,
|
|
default: 'NTS-AEO-ACCESS-ENG,NTS-AEO-STEAM',
|
|
description: 'Comma-separated BU values to sync from Ivanti into the local findings cache',
|
|
docUrl: null,
|
|
sensitive: false,
|
|
validator: null
|
|
},
|
|
{
|
|
name: 'IVANTI_MANAGED_BUS',
|
|
group: 'Ivanti Integration',
|
|
required: false,
|
|
default: 'NTS-AEO-ACCESS-ENG,NTS-AEO-STEAM',
|
|
description: 'Comma-separated BUs considered "managed" for drift classification in the archive',
|
|
docUrl: null,
|
|
sensitive: false,
|
|
validator: null
|
|
},
|
|
{
|
|
name: 'IVANTI_SKIP_TLS',
|
|
group: 'Ivanti Integration',
|
|
required: false,
|
|
default: 'false',
|
|
description: 'Set to true if behind Charter SSL inspection proxy (disables TLS cert verification)',
|
|
docUrl: null,
|
|
sensitive: false,
|
|
validator: null
|
|
},
|
|
|
|
// --- Atlas Integration ---
|
|
{
|
|
name: 'ATLAS_API_URL',
|
|
group: 'Atlas Integration',
|
|
required: false,
|
|
default: null,
|
|
description: 'Base URL for the Atlas InfoSec API (e.g. https://atlas-infosec.caas.charterlab.com)',
|
|
docUrl: 'https://atlas-infosec.caas.charterlab.com — API documentation',
|
|
sensitive: false,
|
|
validator: null
|
|
},
|
|
{
|
|
name: 'ATLAS_API_USER',
|
|
group: 'Atlas Integration',
|
|
required: false,
|
|
default: null,
|
|
description: 'Service account username for Atlas API Basic Auth',
|
|
docUrl: null,
|
|
sensitive: false,
|
|
validator: null
|
|
},
|
|
{
|
|
name: 'ATLAS_API_PASS',
|
|
group: 'Atlas Integration',
|
|
required: false,
|
|
default: null,
|
|
description: 'Service account password for Atlas API Basic Auth',
|
|
docUrl: null,
|
|
sensitive: true,
|
|
validator: null
|
|
},
|
|
{
|
|
name: 'ATLAS_SKIP_TLS',
|
|
group: 'Atlas Integration',
|
|
required: false,
|
|
default: 'false',
|
|
description: 'Set to true if behind Charter SSL inspection proxy (disables TLS cert verification)',
|
|
docUrl: null,
|
|
sensitive: false,
|
|
validator: null
|
|
},
|
|
|
|
// --- Jira Integration ---
|
|
{
|
|
name: 'JIRA_BASE_URL',
|
|
group: 'Jira Integration',
|
|
required: false,
|
|
default: null,
|
|
description: 'Base URL of the Jira Data Center instance (VPN or Charter Network required)',
|
|
docUrl: 'Jira instance URL — requires VPN or Charter Network connection',
|
|
sensitive: false,
|
|
validator: null
|
|
},
|
|
{
|
|
name: 'JIRA_AUTH_METHOD',
|
|
group: 'Jira Integration',
|
|
required: false,
|
|
default: 'basic',
|
|
description: 'Authentication method: "basic" for service account or "pat" for Personal Access Token',
|
|
docUrl: null,
|
|
sensitive: false,
|
|
validator: null
|
|
},
|
|
{
|
|
name: 'JIRA_API_USER',
|
|
group: 'Jira Integration',
|
|
required: false,
|
|
default: null,
|
|
description: 'Service account username for Jira Basic Auth (used when JIRA_AUTH_METHOD=basic)',
|
|
docUrl: null,
|
|
sensitive: false,
|
|
validator: null
|
|
},
|
|
{
|
|
name: 'JIRA_API_TOKEN',
|
|
group: 'Jira Integration',
|
|
required: false,
|
|
default: null,
|
|
description: 'Service account password/token for Jira Basic Auth',
|
|
docUrl: null,
|
|
sensitive: true,
|
|
validator: null
|
|
},
|
|
{
|
|
name: 'JIRA_PAT',
|
|
group: 'Jira Integration',
|
|
required: false,
|
|
default: null,
|
|
description: 'Personal Access Token for Jira (used when JIRA_AUTH_METHOD=pat, requires ATLSUP approval)',
|
|
docUrl: 'PAT naming convention: Function - Team - ATLSUP-XXXXX',
|
|
sensitive: true,
|
|
validator: null
|
|
},
|
|
{
|
|
name: 'JIRA_PROJECT_KEY',
|
|
group: 'Jira Integration',
|
|
required: false,
|
|
default: null,
|
|
description: 'Default Jira project key for creating issues from the dashboard',
|
|
docUrl: null,
|
|
sensitive: false,
|
|
validator: null
|
|
},
|
|
{
|
|
name: 'JIRA_ISSUE_TYPE',
|
|
group: 'Jira Integration',
|
|
required: false,
|
|
default: 'Task',
|
|
description: 'Default issue type when creating Jira tickets from the dashboard',
|
|
docUrl: null,
|
|
sensitive: false,
|
|
validator: null
|
|
},
|
|
{
|
|
name: 'JIRA_SKIP_TLS',
|
|
group: 'Jira Integration',
|
|
required: false,
|
|
default: 'false',
|
|
description: 'Set to true if behind Charter SSL inspection proxy (disables TLS cert verification)',
|
|
docUrl: null,
|
|
sensitive: false,
|
|
validator: null
|
|
},
|
|
|
|
// --- CARD Integration ---
|
|
{
|
|
name: 'CARD_API_URL',
|
|
group: 'CARD Integration',
|
|
required: false,
|
|
default: null,
|
|
description: 'Base URL for the CARD asset ownership API (card.charter.com or staging)',
|
|
docUrl: 'https://card.charter.com — service account must be onboarded with CARD team',
|
|
sensitive: false,
|
|
validator: null
|
|
},
|
|
{
|
|
name: 'CARD_API_USER',
|
|
group: 'CARD Integration',
|
|
required: false,
|
|
default: null,
|
|
description: 'Service account username for CARD API OAuth token acquisition',
|
|
docUrl: null,
|
|
sensitive: false,
|
|
validator: null
|
|
},
|
|
{
|
|
name: 'CARD_API_PASS',
|
|
group: 'CARD Integration',
|
|
required: false,
|
|
default: null,
|
|
description: 'Service account password for CARD API OAuth token acquisition',
|
|
docUrl: null,
|
|
sensitive: true,
|
|
validator: null
|
|
},
|
|
{
|
|
name: 'CARD_SKIP_TLS',
|
|
group: 'CARD Integration',
|
|
required: false,
|
|
default: 'false',
|
|
description: 'Set to true if behind Charter SSL inspection proxy (disables TLS cert verification)',
|
|
docUrl: null,
|
|
sensitive: false,
|
|
validator: null
|
|
},
|
|
|
|
// --- GitLab Integration ---
|
|
{
|
|
name: 'GITLAB_URL',
|
|
group: 'GitLab Integration',
|
|
required: false,
|
|
default: 'http://steam-gitlab.charterlab.com',
|
|
description: 'Base URL of the GitLab instance for feedback submission',
|
|
docUrl: null,
|
|
sensitive: false,
|
|
validator: null
|
|
},
|
|
{
|
|
name: 'GITLAB_PROJECT_ID',
|
|
group: 'GitLab Integration',
|
|
required: false,
|
|
default: null,
|
|
description: 'Numeric project ID from GitLab project settings (Settings > General)',
|
|
docUrl: 'GitLab project > Settings > General — numeric Project ID',
|
|
sensitive: false,
|
|
validator: null
|
|
},
|
|
{
|
|
name: 'GITLAB_PAT',
|
|
group: 'GitLab Integration',
|
|
required: false,
|
|
default: null,
|
|
description: 'GitLab Personal Access Token with "api" scope for creating issues',
|
|
docUrl: 'GitLab > Preferences > Access Tokens — requires "api" scope',
|
|
sensitive: true,
|
|
validator: null
|
|
},
|
|
|
|
// --- Frontend Settings ---
|
|
{
|
|
name: 'REACT_APP_API_BASE',
|
|
group: 'Frontend Settings',
|
|
required: true,
|
|
default: null, // derived from PORT at runtime
|
|
description: 'Full URL to the backend API including /api path (used by React fetch calls)',
|
|
docUrl: null,
|
|
sensitive: false,
|
|
validator: null
|
|
},
|
|
{
|
|
name: 'REACT_APP_API_HOST',
|
|
group: 'Frontend Settings',
|
|
required: true,
|
|
default: null, // derived from PORT at runtime
|
|
description: 'Backend host URL without /api path (used for direct file/download URLs)',
|
|
docUrl: null,
|
|
sensitive: false,
|
|
validator: null
|
|
}
|
|
];
|
|
|
|
// =============================================================================
|
|
// Parsing Functions
|
|
// =============================================================================
|
|
|
|
/**
|
|
* Resolves shell variable substitution syntax ${VAR:-default} by extracting
|
|
* the default value. Returns the original string if the pattern is not found.
|
|
*
|
|
* @param {string} str — input string potentially containing ${VAR:-default}
|
|
* @returns {string} — the extracted default value, or the original string
|
|
*/
|
|
function resolveShellDefault(str) {
|
|
const match = str.match(/\$\{[^:}]+:-([^}]+)\}/);
|
|
return match ? match[1] : str;
|
|
}
|
|
|
|
/**
|
|
* Parses a docker-compose.yml file to extract Postgres service configuration.
|
|
* Uses a simple line-by-line state machine to find the postgres service and
|
|
* extract POSTGRES_USER, POSTGRES_PASSWORD, POSTGRES_DB, and the host port.
|
|
*
|
|
* @param {string} filePath — path to docker-compose.yml
|
|
* @returns {{ user: string, password: string, database: string, port: string } | null}
|
|
*/
|
|
function parseDockerCompose(filePath) {
|
|
let content;
|
|
try {
|
|
content = fs.readFileSync(filePath, 'utf8');
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
|
|
const lines = content.split('\n');
|
|
|
|
// State machine states
|
|
let inServices = false;
|
|
let inPostgres = false;
|
|
let inEnvironment = false;
|
|
let inPorts = false;
|
|
let postgresIndent = -1;
|
|
let sectionIndent = -1;
|
|
|
|
let user = null;
|
|
let password = null;
|
|
let database = null;
|
|
let port = null;
|
|
|
|
for (let i = 0; i < lines.length; i++) {
|
|
const line = lines[i];
|
|
const trimmed = line.trimStart();
|
|
const indent = line.length - trimmed.length;
|
|
|
|
// Look for services: block
|
|
if (trimmed === 'services:' || trimmed.startsWith('services:')) {
|
|
inServices = true;
|
|
continue;
|
|
}
|
|
|
|
if (!inServices) continue;
|
|
|
|
// Look for postgres service (a line like " postgres:" under services)
|
|
if (!inPostgres) {
|
|
if (indent > 0 && /^postgres\s*:/.test(trimmed)) {
|
|
inPostgres = true;
|
|
postgresIndent = indent;
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// If we're in the postgres service, check if we've left it
|
|
// (a line at the same or lesser indent that isn't blank)
|
|
if (trimmed.length > 0 && indent <= postgresIndent) {
|
|
// We've exited the postgres service block
|
|
break;
|
|
}
|
|
|
|
// Look for environment: or ports: section within postgres
|
|
if (!inEnvironment && !inPorts) {
|
|
if (/^environment\s*:/.test(trimmed)) {
|
|
inEnvironment = true;
|
|
sectionIndent = indent;
|
|
continue;
|
|
}
|
|
if (/^ports\s*:/.test(trimmed)) {
|
|
inPorts = true;
|
|
sectionIndent = indent;
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// Inside environment section
|
|
if (inEnvironment) {
|
|
// Check if we've left the environment section
|
|
if (trimmed.length > 0 && indent <= sectionIndent) {
|
|
inEnvironment = false;
|
|
// Check if this line starts a new section
|
|
if (/^ports\s*:/.test(trimmed)) {
|
|
inPorts = true;
|
|
sectionIndent = indent;
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// Parse environment variables (format: KEY: value or KEY: ${VAR:-default})
|
|
const envMatch = trimmed.match(/^(POSTGRES_\w+)\s*:\s*(.+)$/);
|
|
if (envMatch) {
|
|
const key = envMatch[1];
|
|
let value = envMatch[2].trim();
|
|
// Remove surrounding quotes if present
|
|
if ((value.startsWith('"') && value.endsWith('"')) ||
|
|
(value.startsWith("'") && value.endsWith("'"))) {
|
|
value = value.slice(1, -1);
|
|
}
|
|
value = resolveShellDefault(value);
|
|
|
|
if (key === 'POSTGRES_USER') user = value;
|
|
else if (key === 'POSTGRES_PASSWORD') password = value;
|
|
else if (key === 'POSTGRES_DB') database = value;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// Inside ports section
|
|
if (inPorts) {
|
|
// Check if we've left the ports section
|
|
if (trimmed.length > 0 && indent <= sectionIndent) {
|
|
inPorts = false;
|
|
// Check if this line starts a new section
|
|
if (/^environment\s*:/.test(trimmed)) {
|
|
inEnvironment = true;
|
|
sectionIndent = indent;
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// Parse port mapping (format: - "host:container" or - host:container)
|
|
const portMatch = trimmed.match(/^-\s*"?(\d+)\s*:\s*\d+"?/);
|
|
if (portMatch) {
|
|
port = portMatch[1];
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Return null if we couldn't extract all required values
|
|
if (!user || !password || !database || !port) {
|
|
return null;
|
|
}
|
|
|
|
return { user, password, database, port };
|
|
}
|
|
|
|
/**
|
|
* Set of all managed variable names for O(1) lookup during env file parsing.
|
|
*/
|
|
const MANAGED_VARIABLE_NAMES = new Set(VARIABLE_DESCRIPTORS.map(d => d.name));
|
|
|
|
/**
|
|
* Parses a .env file, separating managed variables from unmanaged lines.
|
|
*
|
|
* For each non-empty line:
|
|
* - Lines starting with '#' are treated as comments
|
|
* - Other lines are split on the first '=' to extract key and value
|
|
* - Surrounding double quotes are stripped from the value if present
|
|
* - If the key matches a managed variable name, it goes into the managed Map
|
|
* - Otherwise, the raw line (and any preceding comment lines) go into unmanaged
|
|
*
|
|
* @param {string} filePath — path to the .env file
|
|
* @returns {{ managed: Map<string, string>, unmanaged: string[] }}
|
|
*/
|
|
function parseEnvFile(filePath) {
|
|
try {
|
|
const content = fs.readFileSync(filePath, 'utf8');
|
|
const lines = content.split('\n');
|
|
const managed = new Map();
|
|
const unmanaged = [];
|
|
const pendingComments = [];
|
|
|
|
for (const line of lines) {
|
|
// Skip empty lines
|
|
if (line.trim() === '') {
|
|
// Flush pending comments as unmanaged since they aren't attached to a variable
|
|
if (pendingComments.length > 0) {
|
|
unmanaged.push(...pendingComments);
|
|
pendingComments.length = 0;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// Comment line
|
|
if (line.trimStart().startsWith('#')) {
|
|
pendingComments.push(line);
|
|
continue;
|
|
}
|
|
|
|
// Key=value line — split on first '='
|
|
const eqIndex = line.indexOf('=');
|
|
if (eqIndex === -1) {
|
|
// Malformed line — treat as unmanaged
|
|
if (pendingComments.length > 0) {
|
|
unmanaged.push(...pendingComments);
|
|
pendingComments.length = 0;
|
|
}
|
|
unmanaged.push(line);
|
|
continue;
|
|
}
|
|
|
|
const key = line.substring(0, eqIndex).trim();
|
|
let value = line.substring(eqIndex + 1);
|
|
|
|
// Strip surrounding double quotes from value
|
|
if (value.startsWith('"') && value.endsWith('"') && value.length >= 2) {
|
|
value = value.slice(1, -1);
|
|
}
|
|
|
|
if (MANAGED_VARIABLE_NAMES.has(key)) {
|
|
// Managed variable — discard preceding comments (they're group headers)
|
|
pendingComments.length = 0;
|
|
managed.set(key, value);
|
|
} else {
|
|
// Unmanaged variable — preserve preceding comments
|
|
if (pendingComments.length > 0) {
|
|
unmanaged.push(...pendingComments);
|
|
pendingComments.length = 0;
|
|
}
|
|
unmanaged.push(line);
|
|
}
|
|
}
|
|
|
|
// Flush any trailing pending comments
|
|
if (pendingComments.length > 0) {
|
|
unmanaged.push(...pendingComments);
|
|
}
|
|
|
|
return { managed, unmanaged };
|
|
} catch (err) {
|
|
// File doesn't exist or can't be read
|
|
return { managed: new Map(), unmanaged: [] };
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// Validation Functions
|
|
// =============================================================================
|
|
|
|
/**
|
|
* Validates that the value is a valid TCP port number (integer between 1 and 65535).
|
|
* Leading and trailing whitespace is trimmed before validation.
|
|
*
|
|
* @param {string} value — user-provided port value
|
|
* @returns {{ valid: boolean, message?: string }}
|
|
*/
|
|
function validatePort(value) {
|
|
const trimmed = value.trim();
|
|
const num = Number(trimmed);
|
|
if (!Number.isInteger(num) || num < 1 || num > 65535) {
|
|
return { valid: false, message: 'PORT must be an integer between 1 and 65535' };
|
|
}
|
|
return { valid: true };
|
|
}
|
|
|
|
/**
|
|
* Validates that each comma-separated CORS origin starts with http:// or https://.
|
|
* Whitespace is trimmed from each entry before validation.
|
|
*
|
|
* @param {string} value — comma-separated list of origins
|
|
* @returns {{ valid: boolean, message?: string }}
|
|
*/
|
|
function validateCorsOrigins(value) {
|
|
const entries = value.split(',').map(entry => entry.trim());
|
|
for (const entry of entries) {
|
|
if (!entry.startsWith('http://') && !entry.startsWith('https://')) {
|
|
return { valid: false, message: 'Each CORS origin must start with http:// or https://' };
|
|
}
|
|
}
|
|
return { valid: true };
|
|
}
|
|
|
|
/**
|
|
* Validates that the DATABASE_URL starts with postgresql:// or equals "sqlite".
|
|
*
|
|
* @param {string} value — database connection string
|
|
* @returns {{ valid: boolean, message?: string }}
|
|
*/
|
|
function validateDatabaseUrl(value) {
|
|
if (value.startsWith('postgresql://') || value === 'sqlite') {
|
|
return { valid: true };
|
|
}
|
|
return { valid: false, message: 'DATABASE_URL must start with postgresql:// or be "sqlite"' };
|
|
}
|
|
|
|
/**
|
|
* Validates that the SESSION_SECRET is at least 16 characters long.
|
|
*
|
|
* @param {string} value — session secret value
|
|
* @returns {{ valid: boolean, message?: string }}
|
|
*/
|
|
function validateSessionSecret(value) {
|
|
if (value.length >= 16) {
|
|
return { valid: true };
|
|
}
|
|
return { valid: false, message: 'SESSION_SECRET must be at least 16 characters long' };
|
|
}
|
|
|
|
/**
|
|
* Validates that the value is non-empty and not whitespace-only.
|
|
*
|
|
* @param {string} value — user-provided value
|
|
* @returns {{ valid: boolean, message?: string }}
|
|
*/
|
|
function validateRequired(value) {
|
|
if (value.trim().length === 0) {
|
|
return { valid: false, message: 'This field is required and cannot be empty' };
|
|
}
|
|
return { valid: true };
|
|
}
|
|
|
|
// =============================================================================
|
|
// Display Functions
|
|
// =============================================================================
|
|
|
|
/**
|
|
* Prints a welcome message explaining the wizard's purpose.
|
|
*/
|
|
function printWelcome() {
|
|
console.log('\nCVE Dashboard Configuration Wizard');
|
|
console.log('===================================');
|
|
console.log('This wizard will guide you through configuring backend and frontend');
|
|
console.log('environment variables. Press Ctrl+C at any time to cancel.\n');
|
|
}
|
|
|
|
/**
|
|
* Prints a group section header with its description from GROUP_DESCRIPTIONS.
|
|
*
|
|
* @param {string} group — the group name from GROUP_ORDER
|
|
*/
|
|
function printGroupHeader(group) {
|
|
const description = GROUP_DESCRIPTIONS[group] || '';
|
|
console.log(`\n=== ${group} ===`);
|
|
console.log(description + '\n');
|
|
}
|
|
|
|
/**
|
|
* Masks a sensitive variable value by showing only the first 4 and last 4
|
|
* characters with asterisks in between. If the value is 8 characters or fewer,
|
|
* returns the full value. If the variable name is not in SENSITIVE_VARS,
|
|
* returns the value unchanged.
|
|
*
|
|
* @param {string} name — the variable name
|
|
* @param {string} value — the variable value
|
|
* @returns {string} — the masked or original value
|
|
*/
|
|
function maskSensitive(name, value) {
|
|
if (!SENSITIVE_VARS.includes(name)) {
|
|
return value;
|
|
}
|
|
if (value.length <= 8) {
|
|
return value;
|
|
}
|
|
return value.slice(0, 4) + '****' + value.slice(-4);
|
|
}
|
|
|
|
/**
|
|
* Displays a summary table organized by Variable_Group showing all configured
|
|
* variables with their values. Sensitive variables are masked. Skipped groups
|
|
* are excluded. Shows target file paths and whether each file already exists.
|
|
*
|
|
* @param {Map<string, string>} config — variable name → value
|
|
* @param {Set<string>} skippedGroups — groups the user declined
|
|
*/
|
|
function printSummary(config, skippedGroups) {
|
|
console.log('\n===================================');
|
|
console.log('Configuration Summary');
|
|
console.log('===================================\n');
|
|
|
|
for (const group of GROUP_ORDER) {
|
|
if (skippedGroups.has(group)) {
|
|
continue;
|
|
}
|
|
|
|
const groupVars = VARIABLE_DESCRIPTORS.filter(
|
|
d => d.group === group && config.has(d.name)
|
|
);
|
|
|
|
if (groupVars.length === 0) {
|
|
continue;
|
|
}
|
|
|
|
console.log(`--- ${group} ---`);
|
|
for (const descriptor of groupVars) {
|
|
const value = config.get(descriptor.name);
|
|
const displayValue = maskSensitive(descriptor.name, value);
|
|
console.log(` ${descriptor.name} = ${displayValue}`);
|
|
}
|
|
console.log('');
|
|
}
|
|
|
|
// Show skipped groups
|
|
const skippedList = GROUP_ORDER.filter(g => skippedGroups.has(g));
|
|
if (skippedList.length > 0) {
|
|
console.log('Skipped groups:');
|
|
for (const group of skippedList) {
|
|
console.log(` - ${group}`);
|
|
}
|
|
console.log('');
|
|
}
|
|
|
|
// Show target file paths and existence status
|
|
const backendEnvPath = path.join('backend', '.env');
|
|
const frontendEnvPath = path.join('frontend', '.env');
|
|
const backendExists = fs.existsSync(backendEnvPath);
|
|
const frontendExists = fs.existsSync(frontendEnvPath);
|
|
|
|
console.log('Target files:');
|
|
console.log(` ${backendEnvPath} ${backendExists ? '(exists — will overwrite)' : '(new file)'}`);
|
|
console.log(` ${frontendEnvPath} ${frontendExists ? '(exists — will overwrite)' : '(new file)'}`);
|
|
console.log('');
|
|
}
|
|
|
|
// =============================================================================
|
|
// Prompt Functions
|
|
// =============================================================================
|
|
|
|
/**
|
|
* Map of validator function names to their implementations.
|
|
* Used to look up validators by string name from variable descriptors.
|
|
*/
|
|
const VALIDATORS = {
|
|
validatePort,
|
|
validateCorsOrigins,
|
|
validateDatabaseUrl,
|
|
validateSessionSecret,
|
|
validateRequired
|
|
};
|
|
|
|
/**
|
|
* Prompts the user for a single variable value. Displays the variable label,
|
|
* description, documentation URL, and default value. Validates input and
|
|
* re-prompts on failure.
|
|
*
|
|
* @param {object} rl — readline interface
|
|
* @param {object} descriptor — variable descriptor with name, description, etc.
|
|
* @param {string|null} currentValue — existing value from a parsed env file
|
|
* @returns {Promise<string>} — resolves with the final validated value
|
|
*/
|
|
function promptVariable(rl, descriptor, currentValue) {
|
|
return new Promise((resolve) => {
|
|
const ask = () => {
|
|
// Line 1: [REQUIRED] or [OPTIONAL] label + variable name
|
|
const label = descriptor.required ? '[REQUIRED]' : '[OPTIONAL]';
|
|
console.log(` ${label} ${descriptor.name}`);
|
|
|
|
// Line 2: Description
|
|
console.log(` ${descriptor.description}`);
|
|
|
|
// Line 3: Documentation URL (if present)
|
|
if (descriptor.docUrl !== null) {
|
|
console.log(` Docs: ${descriptor.docUrl}`);
|
|
}
|
|
|
|
// Line 4: Default value display
|
|
let defaultValue = null;
|
|
let defaultLabel = '';
|
|
if (currentValue !== null && currentValue !== undefined) {
|
|
defaultValue = currentValue;
|
|
defaultLabel = '[current]';
|
|
} else if (descriptor.default !== null) {
|
|
defaultValue = descriptor.default;
|
|
defaultLabel = '';
|
|
}
|
|
|
|
if (defaultValue !== null) {
|
|
let displayDefault = defaultValue;
|
|
if (descriptor.sensitive) {
|
|
displayDefault = maskSensitive(descriptor.name, defaultValue);
|
|
}
|
|
const labelSuffix = defaultLabel ? ` ${defaultLabel}` : '';
|
|
console.log(` (${displayDefault}${labelSuffix})`);
|
|
}
|
|
|
|
// Prompt
|
|
rl.question(' > ', (answer) => {
|
|
const trimmedAnswer = answer.trim();
|
|
|
|
// If user enters empty string, use default
|
|
if (trimmedAnswer === '') {
|
|
if (defaultValue !== null) {
|
|
resolve(defaultValue);
|
|
return;
|
|
}
|
|
// No default exists — if required, validate and re-prompt
|
|
if (descriptor.required) {
|
|
const result = validateRequired('');
|
|
console.log(` Error: ${result.message}`);
|
|
ask();
|
|
return;
|
|
}
|
|
// Optional with no default — return empty string
|
|
resolve('');
|
|
return;
|
|
}
|
|
|
|
// Apply validator if one is specified
|
|
if (descriptor.validator) {
|
|
const validatorFn = VALIDATORS[descriptor.validator];
|
|
if (validatorFn) {
|
|
const result = validatorFn(trimmedAnswer);
|
|
if (!result.valid) {
|
|
console.log(` Error: ${result.message}`);
|
|
ask();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
resolve(trimmedAnswer);
|
|
});
|
|
};
|
|
|
|
ask();
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Prompts the user with a yes/no question.
|
|
*
|
|
* @param {object} rl — readline interface
|
|
* @param {string} question — the question to display
|
|
* @param {boolean} defaultNo — if true, default is "no" ([y/N]); if false, default is "yes" ([Y/n])
|
|
* @returns {Promise<boolean>} — resolves to true for yes, false for no
|
|
*/
|
|
function promptYesNo(rl, question, defaultNo) {
|
|
return new Promise((resolve) => {
|
|
const hint = defaultNo ? '[y/N]' : '[Y/n]';
|
|
rl.question(` ${question} ${hint} `, (answer) => {
|
|
const trimmed = answer.trim().toLowerCase();
|
|
if (trimmed === '') {
|
|
resolve(!defaultNo);
|
|
return;
|
|
}
|
|
if (trimmed === 'y' || trimmed === 'yes') {
|
|
resolve(true);
|
|
return;
|
|
}
|
|
if (trimmed === 'n' || trimmed === 'no') {
|
|
resolve(false);
|
|
return;
|
|
}
|
|
// Invalid input — use default
|
|
resolve(!defaultNo);
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Prompts the user to confirm overwriting an existing file. Offers three options:
|
|
* overwrite, create backup then overwrite, or skip.
|
|
*
|
|
* @param {object} rl — readline interface
|
|
* @param {string} filePath — path to the existing file
|
|
* @returns {Promise<string>} — resolves to 'overwrite', 'backup', or 'skip'
|
|
*/
|
|
function promptOverwrite(rl, filePath) {
|
|
return new Promise((resolve) => {
|
|
console.log(`\n File already exists: ${filePath}`);
|
|
console.log(' What would you like to do?');
|
|
console.log(' 1) Overwrite');
|
|
console.log(' 2) Create backup, then overwrite');
|
|
console.log(' 3) Skip (do not write this file)');
|
|
|
|
rl.question(' > ', (answer) => {
|
|
const trimmed = answer.trim();
|
|
if (trimmed === '1') {
|
|
resolve('overwrite');
|
|
} else if (trimmed === '2') {
|
|
resolve('backup');
|
|
} else {
|
|
resolve('skip');
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
// =============================================================================
|
|
// File Writing Functions
|
|
// =============================================================================
|
|
|
|
/**
|
|
* Determines whether a value needs to be wrapped in double quotes.
|
|
* Values containing spaces, '#', or quote characters require quoting.
|
|
*
|
|
* @param {string} value — the variable value to check
|
|
* @returns {boolean} — true if the value needs double-quote wrapping
|
|
*/
|
|
function needsQuoting(value) {
|
|
return value.includes(' ') || value.includes('#') || value.includes('"') || value.includes("'");
|
|
}
|
|
|
|
/**
|
|
* Generates the complete .env file content string from the provided configuration.
|
|
*
|
|
* For each group in groupOrder (that isn't in skippedGroups):
|
|
* - Writes a comment header: `# --- Group Name ---`
|
|
* - For each VARIABLE_DESCRIPTOR in that group:
|
|
* - If the variable has a value in the variables map, writes `KEY=value`
|
|
* - If the value contains spaces, `#`, or quote characters, wraps it in double quotes
|
|
* - If the variable is optional and has no value (not in the map), omits it
|
|
* - Adds a blank line between groups
|
|
*
|
|
* After all groups, if unmanagedLines has entries, adds a `# --- Custom Variables ---`
|
|
* section and appends them.
|
|
*
|
|
* @param {Map<string, string>} variables — variable name → value
|
|
* @param {string[]} groupOrder — array of group names in order
|
|
* @param {object} groupDescriptions — group name → description (unused in output but kept for API consistency)
|
|
* @param {string[]} unmanagedLines — raw lines to preserve in Custom Variables section
|
|
* @param {Set<string>} skippedGroups — groups that were skipped by the user
|
|
* @returns {string} — the complete .env file content
|
|
*/
|
|
function generateEnvContent(variables, groupOrder, groupDescriptions, unmanagedLines, skippedGroups) {
|
|
const sections = [];
|
|
|
|
for (const group of groupOrder) {
|
|
if (skippedGroups.has(group)) {
|
|
continue;
|
|
}
|
|
|
|
const groupVars = VARIABLE_DESCRIPTORS.filter(d => d.group === group);
|
|
const lines = [];
|
|
|
|
for (const descriptor of groupVars) {
|
|
if (variables.has(descriptor.name)) {
|
|
const value = variables.get(descriptor.name);
|
|
if (needsQuoting(value)) {
|
|
lines.push(`${descriptor.name}="${value}"`);
|
|
} else {
|
|
lines.push(`${descriptor.name}=${value}`);
|
|
}
|
|
} else {
|
|
// Optional variable with no value — omit it
|
|
}
|
|
}
|
|
|
|
// Only add the group section if it has at least one variable line
|
|
if (lines.length > 0) {
|
|
sections.push(`# --- ${group} ---\n${lines.join('\n')}`);
|
|
}
|
|
}
|
|
|
|
let content = sections.join('\n\n');
|
|
|
|
// Append unmanaged lines in a Custom Variables section
|
|
if (unmanagedLines && unmanagedLines.length > 0) {
|
|
if (content.length > 0) {
|
|
content += '\n\n';
|
|
}
|
|
content += `# --- Custom Variables ---\n${unmanagedLines.join('\n')}`;
|
|
}
|
|
|
|
// Ensure file ends with a newline
|
|
if (content.length > 0 && !content.endsWith('\n')) {
|
|
content += '\n';
|
|
}
|
|
|
|
return content;
|
|
}
|
|
|
|
/**
|
|
* Creates a timestamped backup copy of an existing file in the same directory.
|
|
* The backup filename follows the pattern: {filename}.backup.{YYYYMMDD_HHmmss}
|
|
*
|
|
* @param {string} filePath — path to the file to back up
|
|
* @returns {string} — the backup file path
|
|
*/
|
|
function createBackup(filePath) {
|
|
const now = new Date();
|
|
const year = now.getFullYear();
|
|
const month = String(now.getMonth() + 1).padStart(2, '0');
|
|
const day = String(now.getDate()).padStart(2, '0');
|
|
const hours = String(now.getHours()).padStart(2, '0');
|
|
const minutes = String(now.getMinutes()).padStart(2, '0');
|
|
const seconds = String(now.getSeconds()).padStart(2, '0');
|
|
const timestamp = `${year}${month}${day}_${hours}${minutes}${seconds}`;
|
|
|
|
const backupPath = `${filePath}.backup.${timestamp}`;
|
|
fs.copyFileSync(filePath, backupPath);
|
|
return backupPath;
|
|
}
|
|
|
|
/**
|
|
* Writes content to a file path. Returns a result object indicating success or failure.
|
|
*
|
|
* @param {string} filePath — path to write the file to
|
|
* @param {string} content — the content to write
|
|
* @returns {{ success: boolean, error?: string }} — result object
|
|
*/
|
|
function writeEnvFile(filePath, content) {
|
|
try {
|
|
fs.writeFileSync(filePath, content);
|
|
return { success: true };
|
|
} catch (err) {
|
|
return { success: false, error: `Failed to write ${filePath}: ${err.message}` };
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// Main Flow
|
|
// =============================================================================
|
|
|
|
/**
|
|
* Main entry point that orchestrates the entire wizard flow.
|
|
* Validates project structure, parses existing config, prompts the user
|
|
* through all variable groups, and writes the resulting env files.
|
|
*/
|
|
async function main() {
|
|
const readline = require('readline');
|
|
|
|
// -------------------------------------------------------------------------
|
|
// 1. Validate project root
|
|
// -------------------------------------------------------------------------
|
|
const backendDir = path.join(process.cwd(), 'backend');
|
|
const frontendDir = path.join(process.cwd(), 'frontend');
|
|
|
|
if (!fs.existsSync(backendDir) || !fs.existsSync(frontendDir)) {
|
|
console.error('Error: This script must be run from the project root (backend/ and frontend/ directories not found). Run from the directory containing both folders.');
|
|
process.exit(1);
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// 2. Parse existing env files for pre-filling
|
|
// -------------------------------------------------------------------------
|
|
const backendEnvPath = path.join('backend', '.env');
|
|
const frontendEnvPath = path.join('frontend', '.env');
|
|
|
|
const existingBackend = parseEnvFile(backendEnvPath);
|
|
const existingFrontend = parseEnvFile(frontendEnvPath);
|
|
|
|
// -------------------------------------------------------------------------
|
|
// 3. Parse docker-compose.yml for DATABASE_URL default
|
|
// -------------------------------------------------------------------------
|
|
const composePath = path.join(process.cwd(), 'docker-compose.yml');
|
|
const composeResult = parseDockerCompose(composePath);
|
|
const FALLBACK_DATABASE_URL = 'postgresql://steam:sV4xmC9xAUCFop0ypxMVS056QgPqGrX@localhost:5433/cve_dashboard';
|
|
|
|
let derivedDatabaseUrl = FALLBACK_DATABASE_URL;
|
|
let databaseUrlSource = 'fallback';
|
|
|
|
if (composeResult) {
|
|
derivedDatabaseUrl = `postgresql://${composeResult.user}:${composeResult.password}@localhost:${composeResult.port}/${composeResult.database}`;
|
|
databaseUrlSource = 'compose';
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// 4. Set up readline and SIGINT handler
|
|
// -------------------------------------------------------------------------
|
|
const rl = readline.createInterface({
|
|
input: process.stdin,
|
|
output: process.stdout
|
|
});
|
|
|
|
process.on('SIGINT', () => {
|
|
rl.close();
|
|
console.log('\n\nConfiguration cancelled. No files were written.');
|
|
process.exit(1);
|
|
});
|
|
|
|
// -------------------------------------------------------------------------
|
|
// 5. Display welcome
|
|
// -------------------------------------------------------------------------
|
|
let restart = true;
|
|
|
|
while (restart) {
|
|
restart = false;
|
|
|
|
printWelcome();
|
|
|
|
// -----------------------------------------------------------------------
|
|
// 6. Group loop — prompt for each variable group
|
|
// -----------------------------------------------------------------------
|
|
const values = new Map();
|
|
const skippedGroups = new Set();
|
|
let confirmedPort = null;
|
|
|
|
for (const group of GROUP_ORDER) {
|
|
// Auto-derive Frontend Settings from PORT and API_HOST — no need to prompt
|
|
if (group === 'Frontend Settings') {
|
|
const port = confirmedPort || '3001';
|
|
const host = values.get('API_HOST') || 'localhost';
|
|
const apiBase = `http://${host}:${port}/api`;
|
|
const apiHost = `http://${host}:${port}`;
|
|
values.set('REACT_APP_API_BASE', apiBase);
|
|
values.set('REACT_APP_API_HOST', apiHost);
|
|
console.log(`\n=== Frontend Settings ===`);
|
|
console.log(` Auto-configured from your backend settings:`);
|
|
console.log(` REACT_APP_API_BASE = ${apiBase}`);
|
|
console.log(` REACT_APP_API_HOST = ${apiHost}`);
|
|
continue;
|
|
}
|
|
|
|
printGroupHeader(group);
|
|
|
|
// For skippable groups, ask if user wants to configure
|
|
if (SKIPPABLE_GROUPS.includes(group)) {
|
|
const configure = await promptYesNo(rl, `Configure ${group}?`, true);
|
|
if (!configure) {
|
|
skippedGroups.add(group);
|
|
console.log(` Skipping ${group}.`);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Get variables for this group
|
|
const groupVars = VARIABLE_DESCRIPTORS.filter(d => d.group === group);
|
|
|
|
for (const descriptor of groupVars) {
|
|
// Determine the effective current value for pre-filling
|
|
let currentValue = null;
|
|
|
|
// Check existing env values first
|
|
if (descriptor.group === 'Frontend Settings') {
|
|
if (existingFrontend.managed.has(descriptor.name)) {
|
|
currentValue = existingFrontend.managed.get(descriptor.name);
|
|
}
|
|
} else {
|
|
if (existingBackend.managed.has(descriptor.name)) {
|
|
currentValue = existingBackend.managed.get(descriptor.name);
|
|
}
|
|
}
|
|
|
|
// If no current value, determine derived defaults for special variables
|
|
if (currentValue === null && descriptor.default === null) {
|
|
if (descriptor.name === 'DATABASE_URL') {
|
|
currentValue = null; // Will use derived default below
|
|
} else if (descriptor.name === 'CORS_ORIGINS') {
|
|
if (confirmedPort !== null) {
|
|
currentValue = null; // Will use derived default below
|
|
}
|
|
}
|
|
}
|
|
|
|
// Build a modified descriptor with the effective default for derived variables
|
|
let effectiveDescriptor = descriptor;
|
|
|
|
if (descriptor.name === 'DATABASE_URL' && currentValue === null && descriptor.default === null) {
|
|
const sourceMsg = databaseUrlSource === 'compose'
|
|
? ' (auto-derived from docker-compose.yml)'
|
|
: ' (fallback from deploy script — docker-compose.yml could not be used)';
|
|
effectiveDescriptor = {
|
|
...descriptor,
|
|
default: derivedDatabaseUrl,
|
|
description: descriptor.description + sourceMsg
|
|
};
|
|
} else if (descriptor.name === 'CORS_ORIGINS' && currentValue === null && descriptor.default === null) {
|
|
effectiveDescriptor = { ...descriptor, default: 'http://localhost:3000' };
|
|
}
|
|
|
|
const result = await promptVariable(rl, effectiveDescriptor, currentValue);
|
|
|
|
// Store the result if non-empty (or if required)
|
|
if (result !== '') {
|
|
values.set(descriptor.name, result);
|
|
}
|
|
|
|
// Track confirmed PORT for deriving other defaults
|
|
if (descriptor.name === 'PORT') {
|
|
confirmedPort = result || '3001';
|
|
}
|
|
}
|
|
|
|
// After Core Settings group completes, derive defaults for later groups
|
|
if (group === 'Core Settings') {
|
|
// CORS_ORIGINS default is already handled inline above
|
|
// REACT_APP_API_BASE and REACT_APP_API_HOST defaults use confirmedPort
|
|
}
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
// 7. Display summary
|
|
// -----------------------------------------------------------------------
|
|
printSummary(values, skippedGroups);
|
|
|
|
// -----------------------------------------------------------------------
|
|
// 8. Confirmation
|
|
// -----------------------------------------------------------------------
|
|
const confirmed = await promptYesNo(rl, 'Write these settings to disk?', false);
|
|
|
|
if (!confirmed) {
|
|
// Ask restart or exit
|
|
const restartChoice = await promptYesNo(rl, 'Restart the wizard from the beginning?', true);
|
|
if (restartChoice) {
|
|
restart = true;
|
|
continue;
|
|
} else {
|
|
rl.close();
|
|
console.log('\nExiting without writing files.');
|
|
process.exit(1);
|
|
}
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
// 9. Handle existing files — prompt for overwrite/backup
|
|
// -----------------------------------------------------------------------
|
|
let writeBackend = true;
|
|
let writeFrontend = true;
|
|
|
|
if (fs.existsSync(backendEnvPath)) {
|
|
const choice = await promptOverwrite(rl, backendEnvPath);
|
|
if (choice === 'skip') {
|
|
writeBackend = false;
|
|
} else if (choice === 'backup') {
|
|
const backupPath = createBackup(backendEnvPath);
|
|
console.log(` Backup created: ${backupPath}`);
|
|
}
|
|
}
|
|
|
|
if (fs.existsSync(frontendEnvPath)) {
|
|
const choice = await promptOverwrite(rl, frontendEnvPath);
|
|
if (choice === 'skip') {
|
|
writeFrontend = false;
|
|
} else if (choice === 'backup') {
|
|
const backupPath = createBackup(frontendEnvPath);
|
|
console.log(` Backup created: ${backupPath}`);
|
|
}
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
// 10. Write files
|
|
// -----------------------------------------------------------------------
|
|
|
|
// Separate variables into backend and frontend
|
|
const backendVars = new Map();
|
|
const frontendVars = new Map();
|
|
|
|
for (const [key, value] of values) {
|
|
const descriptor = VARIABLE_DESCRIPTORS.find(d => d.name === key);
|
|
if (descriptor && descriptor.group === 'Frontend Settings') {
|
|
frontendVars.set(key, value);
|
|
} else {
|
|
backendVars.set(key, value);
|
|
}
|
|
}
|
|
|
|
// Backend groups = all groups except Frontend Settings
|
|
const backendGroups = GROUP_ORDER.filter(g => g !== 'Frontend Settings');
|
|
const frontendGroups = ['Frontend Settings'];
|
|
|
|
if (writeBackend) {
|
|
const backendContent = generateEnvContent(
|
|
backendVars,
|
|
backendGroups,
|
|
GROUP_DESCRIPTIONS,
|
|
existingBackend.unmanaged,
|
|
skippedGroups
|
|
);
|
|
const result = writeEnvFile(backendEnvPath, backendContent);
|
|
if (!result.success) {
|
|
console.error(`Error: ${result.error}`);
|
|
rl.close();
|
|
process.exit(1);
|
|
}
|
|
}
|
|
|
|
if (writeFrontend) {
|
|
const frontendContent = generateEnvContent(
|
|
frontendVars,
|
|
frontendGroups,
|
|
GROUP_DESCRIPTIONS,
|
|
existingFrontend.unmanaged,
|
|
skippedGroups
|
|
);
|
|
const result = writeEnvFile(frontendEnvPath, frontendContent);
|
|
if (!result.success) {
|
|
console.error(`Error: ${result.error}`);
|
|
rl.close();
|
|
process.exit(1);
|
|
}
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
// 11. Success message
|
|
// -----------------------------------------------------------------------
|
|
console.log('\nConfiguration complete!\n');
|
|
console.log('Next steps:');
|
|
console.log(' 1. Run `node backend/setup.js` to initialize the database');
|
|
console.log(' 2. Start the servers with `./start-servers.sh`');
|
|
console.log('');
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// 12. Exit code 0
|
|
// -------------------------------------------------------------------------
|
|
rl.close();
|
|
process.exit(0);
|
|
}
|
|
|
|
// =============================================================================
|
|
// Exports (conditional — only when required as a module, not when run directly)
|
|
// =============================================================================
|
|
|
|
if (typeof require !== 'undefined' && require.main !== module) {
|
|
module.exports = {
|
|
VARIABLE_DESCRIPTORS,
|
|
GROUP_ORDER,
|
|
GROUP_DESCRIPTIONS,
|
|
SKIPPABLE_GROUPS,
|
|
SENSITIVE_VARS,
|
|
MANAGED_VARIABLE_NAMES,
|
|
VALIDATORS,
|
|
resolveShellDefault,
|
|
parseDockerCompose,
|
|
parseEnvFile,
|
|
validatePort,
|
|
validateCorsOrigins,
|
|
validateDatabaseUrl,
|
|
validateSessionSecret,
|
|
validateRequired,
|
|
printWelcome,
|
|
printGroupHeader,
|
|
printSummary,
|
|
maskSensitive,
|
|
promptVariable,
|
|
promptYesNo,
|
|
promptOverwrite,
|
|
needsQuoting,
|
|
generateEnvContent,
|
|
createBackup,
|
|
writeEnvFile,
|
|
main
|
|
};
|
|
}
|
|
|
|
// Run the wizard when executed directly
|
|
if (require.main === module) {
|
|
main();
|
|
}
|