@grada-run/grada 0.0.1 → 0.33.0

package/src/commands/sync-ai.js

@@ -0,0 +1,115 @@
+import fsSync from 'fs';
+import path from 'path';
+import { intro, outro, spinner, log } from '@clack/prompts';
+import color from 'picocolors';
+import { getAiAssistants } from '../utils/prompts.js';
+import { getBaseRules, getCursorRules, injectManagedBlock } from '../utils/ai-rules.js';
+import { trackEvent, flushTelemetry } from '../core/telemetry.js';
+import { failCommand } from '../utils/command.js';
+
+function getProjectContext(cwd) {
+    const context = { region: '', port: '' };
+    const mainTfPath = path.join(cwd, 'terraform', 'main.tf');
+
+    if (fsSync.existsSync(mainTfPath)) {
+        const tfContent = fsSync.readFileSync(mainTfPath, 'utf8');
+
+        // Extract Region
+        const regionMatch = tfContent.match(/region\s*=\s*"([^"]+)"/);
+        if (regionMatch) context.region = regionMatch[1];
+
+        // Extract Port
+        const portMatch = tfContent.match(/containerPort\s*=\s*(\d+)/);
+        if (portMatch) context.port = portMatch[1];
+    }
+
+    return context;
+}
+
+export async function syncAi() {
+    intro(color.bgCyan(color.black(' grada sync-ai 🤖 ')));
+
+    const assistants = await getAiAssistants();
+
+    if (!assistants || assistants.length === 0) {
+        log.warn('No AI assistants selected. Skipping synchronization.');
+        process.exit(0);
+    }
+
+    const s = spinner();
+    s.start('Writing AI context rules...');
+    const cwd = process.cwd();
+
+    const context = getProjectContext(cwd);
+
+    try {
+        // --- Agentic IDEs ---
+        if (assistants.includes('cursor')) {
+            const cursorDir = path.join(cwd, '.cursor', 'rules');
+            if (!fsSync.existsSync(cursorDir)) fsSync.mkdirSync(cursorDir, { recursive: true });
+            fsSync.writeFileSync(path.join(cursorDir, 'grada.mdc'), getCursorRules(context));
+        }
+
+        if (assistants.includes('roo')) {
+            const rooDir = path.join(cwd, '.roo', 'rules');
+            if (!fsSync.existsSync(rooDir)) fsSync.mkdirSync(rooDir, { recursive: true });
+            fsSync.writeFileSync(path.join(rooDir, 'grada.md'), getBaseRules(context));
+        }
+
+        if (assistants.includes('trae')) {
+            const traeDir = path.join(cwd, '.trae', 'rules');
+            if (!fsSync.existsSync(traeDir)) fsSync.mkdirSync(traeDir, { recursive: true });
+            injectManagedBlock(path.join(traeDir, 'project_rules.md'), getBaseRules(context), true);
+        }
+
+        if (assistants.includes('continue')) {
+            const promptsDir = path.join(cwd, '.prompts');
+            if (!fsSync.existsSync(promptsDir)) fsSync.mkdirSync(promptsDir, { recursive: true });
+            fsSync.writeFileSync(path.join(promptsDir, 'grada.prompt'), getBaseRules(context));
+        }
+
+        if (assistants.includes('windsurf')) {
+            injectManagedBlock(path.join(cwd, '.windsurfrules'), getBaseRules(context), false);
+        }
+
+        if (assistants.includes('copilot')) {
+            const githubDir = path.join(cwd, '.github');
+            if (!fsSync.existsSync(githubDir)) fsSync.mkdirSync(githubDir, { recursive: true });
+            injectManagedBlock(path.join(githubDir, 'copilot-instructions.md'), getBaseRules(context), true);
+        }
+
+        // --- Terminal Agents ---
+        if (assistants.includes('claude')) {
+            injectManagedBlock(path.join(cwd, 'CLAUDE.md'), getBaseRules(context), true);
+        }
+
+        if (assistants.includes('goose')) {
+            injectManagedBlock(path.join(cwd, '.goosehints'), getBaseRules(context), true);
+        }
+
+        if (assistants.includes('aider')) {
+            injectManagedBlock(path.join(cwd, '.aider.conf.yml'), getBaseRules(context), false); // Uses # comments
+        }
+
+        s.stop('AI context synchronized successfully!');
+        outro(`${color.green('✅ AI Assistant Rules generated!')} Your AI tools now know exactly how to deploy your app without hallucinating Terraform.`);
+
+        trackEvent('sync_ai_executed', {
+            assistants_selected: assistants,
+            has_cursor: assistants.includes('cursor'),
+            has_roo: assistants.includes('roo'),
+            has_trae: assistants.includes('trae'),
+            has_continue: assistants.includes('continue'),
+            has_windsurf: assistants.includes('windsurf'),
+            has_copilot: assistants.includes('copilot'),
+            has_claude: assistants.includes('claude'),
+            has_goose: assistants.includes('goose'),
+            has_aider: assistants.includes('aider')
+        });
+        await flushTelemetry();
+
+    } catch (error) {
+        s.stop('❌ Failed to write AI context files.');
+        return failCommand({ message: error.message, useErrorStream: true });
+    }
+}

package/src/commands/wake.js

@@ -0,0 +1,337 @@
+import { spawnSync } from 'child_process';
+import { ECSClient, DescribeServicesCommand, UpdateServiceCommand } from '@aws-sdk/client-ecs';
+import { RDSClient, DescribeDBInstancesCommand, DescribeDBClustersCommand, StartDBInstanceCommand, StartDBClusterCommand } from '@aws-sdk/client-rds';
+import color from 'picocolors';
+import { intro, outro, spinner } from '@clack/prompts';
+import { trackSuccess, trackFailure } from '../core/telemetry.js';
+import { failCommand, failProjectNotInitialized } from '../utils/command.js';
+import { parseFlags, normalizeOptions, normalizeArgv } from '../utils/args.js';
+import { handleAuthErrorBranch, resolveClient } from '../utils/aws.js';
+import { resolveRegion, resolveProjectName, resolveCwd, readTerraformComputeTarget } from '../utils/resolvers.js';
+import { findDbTarget } from '../utils/rds.js';
+import { fetchActiveService } from '../utils/ecs.js';
+import { pollUntil } from '../utils/system.js';
+import {
+    resolveSleepTarget,
+    readSleepState,
+    removeSleepStateEntry,
+} from '../utils/sleep-state.js';
+import {
+    readCronScheduleName,
+    hasCronAddon,
+    hasSqsWorkerScaling,
+    setSchedulerState,
+    setWorkerScalingSuspended,
+} from '../utils/sleep-targets.js';
+
+export const DEFAULT_WAKE_TIMEOUT_MS = 600000;
+export const DEFAULT_WAKE_POLL_INTERVAL_MS = 5000;
+
+export function parseWakeArgs(argv = []) {
+    const args = normalizeArgv(argv);
+    if (args[0] === 'wake') args.shift();
+    const { options, rest } = parseFlags(args, {
+        string: ['project-name', 'cluster', 'service', 'db-identifier', 'region', 'workspace'],
+        boolean: ['skip-db', 'wait', 'no-wait', 'yes', 'force', 'headless'],
+    });
+    const positionals = rest.filter((arg) => typeof arg === 'string' && !arg.startsWith('-'));
+    if (positionals.length > 0) options.env = positionals[0];
+    if (positionals.length > 1) options.unexpectedPositionals = positionals.slice(1);
+    return options;
+}
+
+export async function runWake(input = {}) {
+    const options = normalizeOptions(input);
+    let cwd;
+    let region;
+    let projectName;
+    try {
+        cwd = resolveCwd(options);
+        region = resolveRegion(options, cwd);
+        projectName = resolveProjectName(options, cwd);
+    } catch {
+        return failProjectNotInitialized({ event: 'wake_run' });
+    }
+    const target = resolveSleepTarget(options, cwd);
+    const isLambda = readTerraformComputeTarget(cwd) === 'lambda';
+    const skipDb = options.skipDb === true || options.skipDb === 'true';
+    const noWait = options.noWait === true || options.noWait === 'true'
+        || options.wait === false || options.wait === 'false';
+    const timeoutMs = options.timeoutMs ?? DEFAULT_WAKE_TIMEOUT_MS;
+    const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_WAKE_POLL_INTERVAL_MS;
+
+    intro(color.bgCyan(color.black(' grada wake ☀️ ')));
+
+    if (Array.isArray(options.unexpectedPositionals) && options.unexpectedPositionals.length > 0) {
+        return failCommand({
+            message: `\n✖ Unexpected argument "${options.unexpectedPositionals[0]}". Pass a single environment: wake [env].\n`,
+            event: 'wake_run',
+            telemetry: { projectName },
+            errorCode: 'UNEXPECTED_POSITIONAL_ARGS',
+            reason: 'unexpected-positional-args',
+            resultExtra: { cluster: target.cluster, region },
+        });
+    }
+
+    const entry = readSleepState(cwd)[target.envKey] || null;
+    if (entry?.autoRestartAt && Date.now() > Date.parse(entry.autoRestartAt)) {
+        console.log(color.yellow('\n⚠ The 7-day sleep window has elapsed — AWS may have auto-restarted the database already.'));
+    }
+
+    const ecsClient = resolveClient(options.ecsClient, ECSClient, { region });
+    const rdsClient = resolveClient(options.rdsClient, RDSClient, { region });
+    const runSync = options.spawnSyncImpl || spawnSync;
+
+    const s = spinner();
+    s.start(`Waking ${target.envKey}...`);
+
+    try {
+        // 1. Start the database first so booting containers never
+        // crash-loop on an unreachable database.
+        let dbTarget = null;
+        let dbStarted = false;
+        if (!skipDb) {
+            dbTarget = await findDbTarget(rdsClient, {
+                dbIdentifier: target.dbIdentifier,
+                dbClusterIdentifier: target.dbClusterIdentifier,
+            });
+            if (dbTarget && dbTarget.status === 'stopped') {
+                if (dbTarget.kind === 'cluster') {
+                    await rdsClient.send(new StartDBClusterCommand({ DBClusterIdentifier: dbTarget.id }));
+                } else {
+                    await rdsClient.send(new StartDBInstanceCommand({ DBInstanceIdentifier: dbTarget.id }));
+                }
+                dbStarted = true;
+            }
+        }
+
+        if (!noWait && dbTarget && dbStarted) {
+            const isCluster = dbTarget.kind === 'cluster';
+            s.message(`Waiting for ${dbTarget.id} to become available...`);
+            const outcome = await pollUntil({
+                intervalMs: pollIntervalMs,
+                timeoutMs,
+                ...(options.sleepFn ? { sleepFn: options.sleepFn } : {}),
+                ...(options.nowFn ? { nowFn: options.nowFn } : {}),
+                onTick: async ({ elapsedMs }) => {
+                    const resp = isCluster
+                        ? await rdsClient.send(new DescribeDBClustersCommand({ DBClusterIdentifier: dbTarget.id }))
+                        : await rdsClient.send(new DescribeDBInstancesCommand({ DBInstanceIdentifier: dbTarget.id }));
+                    const current = isCluster
+                        ? (resp.DBClusters || [])[0] || null
+                        : (resp.DBInstances || [])[0] || null;
+                    if (current && current.Status === 'available') return { done: true, value: current };
+                    s.message(`Waiting for ${dbTarget.id}... [${Math.floor(elapsedMs / 1000)}s]`);
+                    return { done: false };
+                },
+            });
+            if (outcome.timedOut) {
+                s.stop(color.yellow('Database still starting.'));
+                return failCommand({
+                    print: () => {
+                        console.log(color.yellow(`\n⚠ ${dbTarget.id} did not become available in time.`));
+                        console.log(isLambda
+                            ? `  The environment is still asleep — re-run ${color.green(`npx grada-run wake${target.envKey === 'default' ? '' : ` ${target.envKey}`}`)} once the database is available.\n`
+                            : `  ECS services were left asleep — re-run ${color.green(`npx grada-run wake${target.envKey === 'default' ? '' : ` ${target.envKey}`}`)} once the database is available.\n`);
+                    },
+                    event: 'wake_run',
+                    telemetry: { projectName, env_kind: target.envKind },
+                    errorCode: 'RDS_WAKE_TIMEOUT',
+                    reason: 'rds-wake-timeout',
+                    resultExtra: { cluster: target.cluster, region },
+                });
+            }
+        }
+
+        // 2. Restore ECS desired counts (ledger first, then 1/1 defaults).
+        // Lambda ledgers store 0/0: there is nothing to restore.
+        const desiredApp = isLambda ? (entry?.services?.app ?? 0) : Math.max(1, entry?.services?.app ?? 1);
+        const desiredWorker = isLambda ? (entry?.services?.worker ?? 0) : Math.max(1, entry?.services?.worker ?? 1);
+        const restored = [];
+        for (const [serviceName, desired] of [
+            [target.appService, desiredApp],
+            [target.workerService, desiredWorker],
+        ]) {
+            if (desired <= 0) continue;
+            const service = await fetchActiveService(ecsClient, target.cluster, serviceName);
+            if (!service) continue;
+            await ecsClient.send(new UpdateServiceCommand({
+                cluster: target.cluster,
+                service: serviceName,
+                desiredCount: desired,
+            }));
+            restored.push({ name: serviceName, desired });
+        }
+
+        if (restored.length === 0 && !dbTarget) {
+            s.stop(color.yellow('Nothing to wake.'));
+            return failCommand({
+                print: () => {
+                    if (isLambda) {
+                        console.log(`\n  No databases found for ${color.cyan(target.appPrefix)} — and Lambda compute needs no wake-up.`);
+                    } else {
+                        console.log(`\n  No ECS services or databases found for ${color.cyan(target.appPrefix)}.`);
+                    }
+                    console.log(`  Run ${color.green('npx grada-run apply')} to provision your infrastructure.\n`);
+                },
+                event: 'wake_run',
+                telemetry: { projectName, env_kind: target.envKind, error_code: 'NOTHING_TO_WAKE' },
+                reason: 'nothing-to-wake',
+                resultExtra: { cluster: target.cluster, region },
+            });
+        }
+
+        // Resume the scheduled work sleep paused. A resume failure warns
+        // loudly — a schedule left disabled would silently stop cron — but
+        // the environment itself is already awake, so wake still succeeds.
+        const cronConfigured = hasCronAddon(cwd);
+        let cronName = null;
+        let cronResumed = false;
+        let cronNote = null;
+        if (cronConfigured) {
+            cronName = readCronScheduleName(cwd, target.appPrefix);
+            if (!cronName) {
+                cronNote = 'schedule name unreadable, skipped';
+            } else {
+                const resumed = setSchedulerState({ name: cronName, enabled: true, region, run: runSync });
+                if (resumed.ok) {
+                    cronResumed = true;
+                    if (resumed.skipped) cronNote = 'already running';
+                } else if (resumed.reason === 'not-deployed') {
+                    cronNote = 'not deployed yet, skipped';
+                } else if (resumed.reason === 'cli-missing') {
+                    cronNote = 'skipped (AWS CLI not found)';
+                } else {
+                    cronNote = `could not resume (${resumed.detail || resumed.reason})`;
+                }
+            }
+        }
+        const scalingConfigured = hasSqsWorkerScaling(cwd);
+        let scalingResumed = false;
+        let scalingNote = null;
+        if (scalingConfigured) {
+            const resumed = setWorkerScalingSuspended({
+                cluster: target.cluster, service: target.workerService, suspended: false, region, run: runSync,
+            });
+            if (resumed.ok) {
+                scalingResumed = true;
+                if (resumed.skipped) scalingNote = 'already active';
+            } else if (resumed.reason === 'not-registered') {
+                scalingNote = 'not registered, skipped';
+            } else if (resumed.reason === 'cli-missing') {
+                scalingNote = 'skipped (AWS CLI not found)';
+            } else {
+                scalingNote = `could not resume (${resumed.detail || resumed.reason})`;
+            }
+        }
+
+        if (!noWait && restored.length > 0) {
+            s.message('Waiting for ECS tasks to start...');
+            const outcome = await pollUntil({
+                intervalMs: pollIntervalMs,
+                timeoutMs,
+                ...(options.sleepFn ? { sleepFn: options.sleepFn } : {}),
+                ...(options.nowFn ? { nowFn: options.nowFn } : {}),
+                onTick: async ({ elapsedMs }) => {
+                    const resp = await ecsClient.send(new DescribeServicesCommand({
+                        cluster: target.cluster,
+                        services: restored.map((r) => r.name),
+                    }));
+                    const services = resp.services || [];
+                    const ready = restored.every(({ name, desired }) => {
+                        const svc = services.find((candidate) => candidate.serviceName === name || candidate.serviceArn?.endsWith(`/${name}`));
+                        return svc && (svc.runningCount ?? 0) >= desired;
+                    });
+                    if (ready) return { done: true, value: true };
+                    s.message(`Waiting for ECS tasks... [${Math.floor(elapsedMs / 1000)}s]`);
+                    return { done: false };
+                },
+            });
+            if (outcome.timedOut) {
+                s.stop(color.yellow('ECS tasks still starting.'));
+                return failCommand({
+                    print: () => {
+                        console.log(color.yellow('\n⚠ ECS tasks did not reach the desired count in time.'));
+                        console.log(`  The restore was applied — check progress with ${color.green('npx grada-run status')}.\n`);
+                    },
+                    event: 'wake_run',
+                    telemetry: { projectName, env_kind: target.envKind },
+                    errorCode: 'ECS_WAKE_TIMEOUT',
+                    reason: 'ecs-wake-timeout',
+                    resultExtra: { cluster: target.cluster, region },
+                });
+            }
+        }
+
+        removeSleepStateEntry(cwd, target.envKey);
+
+        s.stop(color.green('Environment awake. ☀️'));
+        console.log('');
+        if (isLambda) {
+            console.log(`  ${color.dim('lambda:')} scale-to-zero compute — nothing to restore`);
+        }
+        if (skipDb) {
+            console.log(`  ${color.dim('rds:')} skipped (--skip-db)`);
+        } else if (dbStarted) {
+            console.log(`  ${color.dim('rds:')} ${color.cyan(dbTarget.id)} started`);
+        } else if (dbTarget) {
+            console.log(`  ${color.dim('rds:')} ${color.cyan(dbTarget.id)} already ${dbTarget.status}`);
+        } else {
+            console.log(`  ${color.dim('rds:')} no database provisioned`);
+        }
+        for (const { name, desired } of restored) {
+            console.log(`  ${color.dim('ecs:')} ${color.cyan(name)} restored to ${desired}`);
+        }
+        if (cronConfigured) {
+            const label = cronName ? `${color.cyan(cronName)} ` : '';
+            console.log(`  ${color.dim('cron:')} ${label}${cronResumed && !cronNote ? 'resumed' : cronNote}`);
+        }
+        if (scalingConfigured) {
+            console.log(`  ${color.dim('scaling:')} ${scalingResumed && !scalingNote ? 'worker auto-scaling resumed' : scalingNote}`);
+        }
+        console.log('');
+
+        await trackSuccess('wake_run', {
+            projectName,
+            env_kind: target.envKind,
+            ecs_restored: restored.length,
+            db_started: dbStarted,
+            waited: !noWait,
+            cron_resumed: cronResumed,
+            scaling_resumed: scalingResumed,
+        });
+        outro(color.green('Done.'));
+        return {
+            ok: true,
+            env: target.envKey,
+            cluster: target.cluster,
+            region,
+            ecsRestored: restored.length,
+            dbStarted,
+            waited: !noWait,
+            cronResumed,
+            scalingResumed,
+        };
+    } catch (error) {
+        await trackFailure('wake_run', {
+            projectName,
+            env_kind: target.envKind,
+            error_code: error?.name || 'UNKNOWN',
+            error_message: error?.message,
+        });
+        if (handleAuthErrorBranch(error, s, options)) {
+            return { ok: false, reason: 'error', cluster: target.cluster, region };
+        }
+        try { s.stop(color.red('❌ Wake failed.')); } catch { /* spinner already stopped */ }
+        return failCommand({
+            message: `✖ ${error?.message || error}`,
+            hint: 'Check your AWS credentials and region, then try again.',
+            reason: 'error',
+            resultExtra: { cluster: target.cluster, region },
+        });
+    }
+}
+
+export const wakeCommand = runWake;
+
+export default runWake;

package/src/core/parser.js

@@ -0,0 +1,128 @@
+import { normalizeArgv } from '../utils/args.js';
+
+export function parseCliArgs(processArgs) {
+    const argv = normalizeArgv(processArgs);
+    // 1. Extract telemetry flag safely
+    const hasNoTelemetry = argv.some(arg => arg === '--no-telemetry' || (typeof arg === 'string' && arg.startsWith('--no-telemetry=')));
+
+    // 2. Filter out telemetry flag
+    const args = argv.filter(arg => arg !== '--no-telemetry' && !(typeof arg === 'string' && arg.startsWith('--no-telemetry=')));
+
+    // 3. Flag readers. Every value flag supports both `--flag=value` and
+    // `--flag value` spellings; space-form values are recorded in
+    // `consumed` so section 5 can keep them out of the positional
+    // command string. Boolean flags never consume the next token.
+    const consumed = new Set();
+
+    const getValueFlag = (flagName) => {
+        for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+            if (typeof arg !== 'string') continue;
+            if (arg.startsWith(`--${flagName}=`)) {
+                const value = arg.slice(flagName.length + 3);
+                return value === '' ? null : value;
+            }
+            if (arg === `--${flagName}`) {
+                const next = args[i + 1];
+                if (typeof next === 'string' && next !== '' && !next.startsWith('--')) {
+                    consumed.add(i + 1);
+                    return next;
+                }
+                return null;
+            }
+        }
+        return null;
+    };
+
+    const getBoolFlag = (flagName) => {
+        for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+            if (typeof arg !== 'string') continue;
+            if (arg.startsWith(`--${flagName}=`)) {
+                return arg.slice(flagName.length + 3) === 'true';
+            }
+            if (arg === `--${flagName}`) return true;
+        }
+        return null;
+    };
+
+    // 4. Parse execution flags
+    const isHeadless = args.includes('--headless');
+    const isDryRun = args.includes('--dry-run');
+    const isPreconfigured = args.includes('--preconfigured');
+
+    // Headless values are always parsed (so consumption marking is
+    // mode-independent) but only exposed in headless mode.
+    const headlessValues = {
+        dir: getValueFlag('dir'),
+        framework: getValueFlag('framework'),
+        region: getValueFlag('region'),
+        port: getValueFlag('port'),
+        size: getValueFlag('size'),
+        healthCheckPath: getValueFlag('healthCheckPath'),
+        desiredCount: getValueFlag('desiredCount'),
+        branch: getValueFlag('branch'),
+        needsDatabase: getBoolFlag('needsDatabase'),
+        enablePrPreviews: getBoolFlag('enablePrPreviews')
+    };
+    const headlessOptions = isHeadless ? headlessValues : {};
+
+    const parseWithFlag = () => {
+        const values = [];
+        for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+            if (typeof arg !== 'string') continue;
+            if (arg === '--with') {
+                const next = args[i + 1];
+                if (typeof next === 'string' && next !== '' && !next.startsWith('--')) {
+                    consumed.add(i + 1);
+                    values.push(...next.split(','));
+                }
+                continue;
+            }
+            if (arg.startsWith('--with=')) {
+                values.push(...arg.slice('--with='.length).split(','));
+            }
+        }
+        const seen = new Set();
+        const deduped = [];
+        for (const raw of values) {
+            const value = String(raw).trim();
+            if (!value || seen.has(value)) continue;
+            seen.add(value);
+            deduped.push(value);
+        }
+        return deduped;
+    };
+
+    const initOptions = {
+        with: parseWithFlag(),
+        model: getValueFlag('model'),
+        domain: getValueFlag('domain'),
+        zoneId: getValueFlag('zone-id'),
+        fromEmail: getValueFlag('from-email'),
+        dbEngine: getValueFlag('db-engine'),
+        target: getValueFlag('target'),
+        setupCiMigrate: args.includes('--setup-ci-migrate'),
+        setupCiDrift: args.includes('--setup-ci-drift'),
+    };
+
+    // 5. Isolate positional commands (non-string elements are positionals;
+    // values consumed by space-form flags are excluded).
+    const isFlag = (arg) => typeof arg === 'string' && arg.startsWith('--');
+    const positionalArgs = args.filter((arg, idx) => !isFlag(arg) && !consumed.has(idx));
+    const baseCommand = positionalArgs.length > 0 ? positionalArgs.slice(0, 2).join(' ') : 'init';
+
+    return {
+        hasNoTelemetry,
+        positionalArgs,
+        baseCommand,
+        isHeadless,
+        isDryRun,
+        isPreconfigured,
+        autoApprove: getBoolFlag('auto-approve') === true,
+        yes: getBoolFlag('yes') === true,
+        headlessOptions,
+        initOptions
+    };
+}