grada-run 0.0.2 → 0.33.0

package/src/utils/sleep-state.js

@@ -0,0 +1,140 @@
+import fsSync from 'fs';
+import path from 'path';
+import { normalizeOptions } from './args.js';
+import { resolveProjectName, resolveWorkspaceSuffix, resolveCluster, resolveService, resolveCwd } from './resolvers.js';
+import { resolveDbIdentifier, resolveDbClusterIdentifier } from './rds.js';
+
+export const SLEEP_STATE_DIRNAME = '.grada';
+export const LEGACY_SLEEP_STATE_DIRNAME = '.deploy-stack';
+export const SLEEP_STATE_FILENAME = 'sleep-state.json';
+export const RDS_AUTO_RESTART_DAYS = 7;
+export const RDS_AUTO_RESTART_MS = RDS_AUTO_RESTART_DAYS * 24 * 60 * 60 * 1000;
+
+// Environment aliases that address the default/production environment.
+// Returns the canonical env name, or null when no env was requested.
+export function normalizeSleepEnv(rawEnv) {
+    if (typeof rawEnv !== 'string') return null;
+    const trimmed = rawEnv.trim();
+    if (trimmed === '') return null;
+    const lowered = trimmed.toLowerCase();
+    if (lowered === 'default' || lowered === 'prod' || lowered === 'production') return 'default';
+    return trimmed;
+}
+
+// Shared target resolution for `sleep` / `wake`: an explicit `--workspace`
+// wins over the positional `[env]`; either beats the
+// `.terraform/environment` auto-detect; otherwise the default environment.
+// Explicit `--cluster` / `--service` / `--db-identifier` overrides still win
+// inside the resolvers. Returns `{ envKey, envKind, requiresConfirm,
+// appPrefix, cluster, appService, workerService, dbIdentifier,
+// dbClusterIdentifier }`.
+export function resolveSleepTarget(options = {}, cwd = process.cwd()) {
+    const opts = normalizeOptions(options);
+    const base = resolveCwd(opts, cwd);
+    const projectName = resolveProjectName(opts, base);
+    const rawEnv = (typeof opts.workspace === 'string' && opts.workspace.trim() !== '')
+        ? opts.workspace
+        : opts.env;
+    const env = normalizeSleepEnv(rawEnv);
+    const scoped = { ...opts, workspace: env === null ? opts.workspace : env };
+    const suffix = resolveWorkspaceSuffix(scoped, base);
+    const appPrefix = `${projectName}${suffix}`;
+    const prefixed = { ...scoped, projectName: appPrefix };
+    const unprefixed = { ...scoped, projectName };
+    return {
+        envKey: suffix === '' ? 'default' : suffix.slice(1),
+        envKind: suffix === '' ? 'default' : 'named',
+        // The production guard fires unless an explicit non-default env was
+        // passed — an auto-detected named workspace still prompts, since the
+        // user never named it on the command line.
+        requiresConfirm: env === null || env === 'default',
+        appPrefix,
+        cluster: resolveCluster(prefixed, base),
+        appService: resolveService(prefixed, base),
+        workerService: `${appPrefix}-worker-service`,
+        dbIdentifier: resolveDbIdentifier(unprefixed, base),
+        dbClusterIdentifier: resolveDbClusterIdentifier(unprefixed, base),
+    };
+}
+
+export function sleepStatePath(cwd = process.cwd()) {
+    return path.join(resolveCwd({}, cwd), SLEEP_STATE_DIRNAME, SLEEP_STATE_FILENAME);
+}
+
+export function legacySleepStatePath(cwd = process.cwd()) {
+    return path.join(resolveCwd({}, cwd), LEGACY_SLEEP_STATE_DIRNAME, SLEEP_STATE_FILENAME);
+}
+
+function readLedgerFile(filePath) {
+    try {
+        const parsed = JSON.parse(fsSync.readFileSync(filePath, 'utf8'));
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) return parsed;
+    } catch {
+        // Fall through to null below.
+    }
+    return null;
+}
+
+// Reads the per-env sleep ledger (`{ [env]: entry }`). The new `.grada/`
+// path wins; the legacy `.deploy-stack/` path is a read fallback so
+// pre-rebrand projects wake cleanly. Missing or corrupt files read as
+// empty so a hand-edited file never crashes wake/sleep.
+export function readSleepState(cwd = process.cwd()) {
+    return readLedgerFile(sleepStatePath(cwd))
+        ?? readLedgerFile(legacySleepStatePath(cwd))
+        ?? {};
+}
+
+export function writeSleepState(cwd = process.cwd(), state = {}) {
+    const filePath = sleepStatePath(cwd);
+    fsSync.mkdirSync(path.dirname(filePath), { recursive: true });
+    fsSync.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+}
+
+export function removeSleepStateEntry(cwd = process.cwd(), envKey = 'default') {
+    const state = readSleepState(cwd);
+    if (!Object.prototype.hasOwnProperty.call(state, envKey)) return false;
+    delete state[envKey];
+    writeSleepState(cwd, state);
+    return true;
+}
+
+// Keeps the advisory sleep ledger out of git. Returns true when the file was
+// created or amended, false when the rule already existed or the write failed.
+export function ensureSleepGitignore(cwd = process.cwd()) {
+    const base = resolveCwd({}, cwd);
+    const file = path.join(base, '.gitignore');
+    let content = null;
+    try {
+        if (fsSync.existsSync(file)) content = fsSync.readFileSync(file, 'utf8');
+    } catch {
+        content = null;
+    }
+    if (typeof content === 'string' && content.split('\n').some((line) => line.trim() === `${SLEEP_STATE_DIRNAME}/`)) {
+        return false;
+    }
+    const entry = `# Local grada runtime state (sleep/wake)\n${SLEEP_STATE_DIRNAME}/\n`;
+    try {
+        if (content === null) {
+            fsSync.writeFileSync(file, entry, 'utf8');
+        } else {
+            fsSync.appendFileSync(file, content.endsWith('\n') ? `\n${entry}` : `\n\n${entry}`, 'utf8');
+        }
+    } catch {
+        return false;
+    }
+    return true;
+}
+
+// AWS automatically restarts stopped RDS instances and Aurora clusters after
+// 7 consecutive days. Pure over an injectable clock for unit tests.
+export function computeAutoRestartAt(nowMs = Date.now()) {
+    return new Date(nowMs + RDS_AUTO_RESTART_MS);
+}
+
+export function formatUtcTimestamp(date) {
+    const d = date instanceof Date ? date : new Date(date);
+    const pad = (value) => String(value).padStart(2, '0');
+    return `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}`
+        + ` ${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())} UTC`;
+}

package/src/utils/sleep-targets.js

@@ -0,0 +1,139 @@
+import fsSync from 'fs';
+import path from 'path';
+
+// Auxiliary sleep/wake targets driven through the AWS CLI: EventBridge
+// Scheduler pause/resume and ECS Application Auto Scaling suspend/resume.
+// The repo has no @aws-sdk/client-scheduler or
+// @aws-sdk/client-application-auto-scaling dependency, and `doctor`
+// already requires the AWS CLI — so these helpers shell out through an
+// injectable `run` (spawnSync-shaped, mirroring drift.js `spawnSyncImpl`)
+// instead of adding new npm packages. Every helper degrades to a skip
+// reason; callers warn and continue so sleep/wake never fail on these.
+
+// cron.tf renders `name = "${local.app_name}-cron-<slug>"`. Resolves the
+// live schedule name for an app prefix, or null when cron isn't configured
+// (or the file was hand-edited past recognition).
+export function readCronScheduleName(cwd, appPrefix) {
+    let content;
+    try {
+        content = fsSync.readFileSync(path.join(cwd, 'terraform', 'cron.tf'), 'utf8');
+    } catch {
+        return null;
+    }
+    const match = /\$\{local\.app_name\}-cron-([A-Za-z0-9-]+)/.exec(content);
+    if (!match) return null;
+    return `${appPrefix}-cron-${match[1]}`;
+}
+
+export function hasCronAddon(cwd) {
+    return fsSync.existsSync(path.join(cwd, 'terraform', 'cron.tf'));
+}
+
+// The SQS queue-depth scaling target exists only when the queue addon was
+// scaffolded alongside a worker service.
+export function hasSqsWorkerScaling(cwd) {
+    return fsSync.existsSync(path.join(cwd, 'terraform', 'sqs.tf'))
+        && fsSync.existsSync(path.join(cwd, 'terraform', 'worker.tf'));
+}
+
+export function hasRedisAddon(cwd) {
+    return fsSync.existsSync(path.join(cwd, 'terraform', 'redis.tf'));
+}
+
+function tailLines(output, count = 5) {
+    return String(output ?? '').split('\n').slice(-count).join('\n').trim();
+}
+
+// Fetches the full schedule document. Never throws: missing CLI,
+// undeployed schedules, and parse failures all return skip reasons.
+export function getSchedulerSchedule({ name, region, run }) {
+    const res = run('aws', [
+        'scheduler', 'get-schedule',
+        '--name', name,
+        '--region', region,
+        '--output', 'json',
+    ], { encoding: 'utf8' });
+    if (res?.error?.code === 'ENOENT') return { ok: false, reason: 'cli-missing' };
+    if (res?.status !== 0) {
+        const detail = tailLines(res?.stderr || res?.stdout);
+        if (/ResourceNotFound/i.test(detail)) return { ok: false, reason: 'not-deployed' };
+        return { ok: false, reason: 'get-failed', detail };
+    }
+    try {
+        return { ok: true, schedule: JSON.parse(res.stdout) };
+    } catch {
+        return { ok: false, reason: 'bad-response' };
+    }
+}
+
+// UpdateSchedule is a full PUT replacement: the fetched document is passed
+// back with only State flipped. Get-only fields (Arn, CreationDate,
+// LastModificationDate) are dropped so --cli-input-json validates.
+export function setSchedulerState({ name, enabled, region, run }) {
+    const got = getSchedulerSchedule({ name, region, run });
+    if (!got.ok) return got;
+    const desired = enabled ? 'ENABLED' : 'DISABLED';
+    if (got.schedule?.State === desired) return { ok: true, skipped: 'already' };
+    const s = got.schedule;
+    const payload = { Name: name, State: desired };
+    for (const key of ['GroupName', 'ScheduleExpression', 'ScheduleExpressionTimezone',
+        'FlexibleTimeWindow', 'Target', 'Description', 'StartDate', 'EndDate',
+        'ActionAfterCompletion', 'KmsKeyArn']) {
+        if (s[key] !== undefined && s[key] !== null) payload[key] = s[key];
+    }
+    const res = run('aws', [
+        'scheduler', 'update-schedule',
+        '--cli-input-json', JSON.stringify(payload),
+        '--region', region,
+        '--output', 'json',
+    ], { encoding: 'utf8' });
+    if (res?.error?.code === 'ENOENT') return { ok: false, reason: 'cli-missing' };
+    if (res?.status !== 0) return { ok: false, reason: 'update-failed', detail: tailLines(res?.stderr || res?.stdout) };
+    return { ok: true };
+}
+
+export function scalableTargetId(cluster, service) {
+    return `service/${cluster}/${service}`;
+}
+
+// Suspends (sleep) or resumes (wake) worker auto-scaling. Min/max capacity
+// are omitted so a registered target keeps its limits; unregistered
+// targets (sqs.tf rendered while workerless) skip quietly.
+export function setWorkerScalingSuspended({ cluster, service, suspended, region, run }) {
+    const resourceId = scalableTargetId(cluster, service);
+    const described = run('aws', [
+        'application-autoscaling', 'describe-scalable-targets',
+        '--service-namespace', 'ecs',
+        '--resource-ids', resourceId,
+        '--region', region,
+        '--output', 'json',
+    ], { encoding: 'utf8' });
+    if (described?.error?.code === 'ENOENT') return { ok: false, reason: 'cli-missing' };
+    if (described?.status !== 0) {
+        return { ok: false, reason: 'describe-failed', detail: tailLines(described?.stderr || described?.stdout) };
+    }
+    let targets = [];
+    try {
+        targets = JSON.parse(described.stdout || '{}').ScalableTargets || [];
+    } catch {
+        return { ok: false, reason: 'bad-response' };
+    }
+    if (targets.length === 0) return { ok: false, reason: 'not-registered' };
+    const state = targets[0].SuspendedState || {};
+    const already = suspended
+        ? state.DynamicScalingInSuspended === true && state.DynamicScalingOutSuspended === true && state.ScheduledScalingSuspended === true
+        : state.DynamicScalingInSuspended !== true && state.DynamicScalingOutSuspended !== true && state.ScheduledScalingSuspended !== true;
+    if (already) return { ok: true, skipped: 'already' };
+    const v = suspended ? 'true' : 'false';
+    const res = run('aws', [
+        'application-autoscaling', 'register-scalable-target',
+        '--service-namespace', 'ecs',
+        '--scalable-dimension', 'ecs:service:DesiredCount',
+        '--resource-id', resourceId,
+        '--suspended-state', `DynamicScalingInSuspended=${v},DynamicScalingOutSuspended=${v},ScheduledScalingSuspended=${v}`,
+        '--region', region,
+    ], { encoding: 'utf8' });
+    if (res?.error?.code === 'ENOENT') return { ok: false, reason: 'cli-missing' };
+    if (res?.status !== 0) return { ok: false, reason: 'update-failed', detail: tailLines(res?.stderr || res?.stdout) };
+    return { ok: true };
+}

package/src/utils/system.js

@@ -0,0 +1,42 @@
+import util from 'util';
+import { exec } from 'child_process';
+
+const execAsync = util.promisify(exec);
+
+export async function checkDependency(command) {
+    try {
+        await execAsync(`${command} --version`);
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// Parses a `--timeout` flag value (seconds). Returns the default when the
+// flag is omitted, the positive integer when valid, or null when invalid.
+export function parseTimeoutSeconds(value, defaultSeconds) {
+    if (value === undefined || value === null || String(value).trim() === '') return defaultSeconds;
+    if (!/^\d+$/.test(String(value).trim())) return null;
+    const seconds = Number(String(value).trim());
+    if (!Number.isSafeInteger(seconds) || seconds <= 0) return null;
+    return seconds;
+}
+
+// Shared polling loop: runs `onTick({ elapsedMs })` immediately, then every
+// `intervalMs`, until it resolves `{ done: true, value }` or `timeoutMs`
+// elapses. Resolves `{ done: true, value }` or `{ timedOut: true }`.
+// `sleepFn`/`nowFn` are injectable so tests never wait on real timers.
+export async function pollUntil({ intervalMs = 2000, timeoutMs = 600000, sleepFn = sleep, nowFn = Date.now, onTick }) {
+    const startTime = nowFn();
+    for (;;) {
+        const elapsedMs = nowFn() - startTime;
+        if (elapsedMs >= timeoutMs) return { timedOut: true };
+        const outcome = await onTick({ elapsedMs });
+        if (outcome && outcome.done) return { done: true, value: outcome.value };
+        await sleepFn(intervalMs);
+    }
+}

package/src/utils/terraform.js

@@ -0,0 +1,70 @@
+import { spawn } from 'child_process';
+import color from 'picocolors';
+
+// Runs a terraform command while piping the latest stdout line into a
+// @clack spinner. Resolves on exit 0; rejects with the captured stderr
+// (or the exit code) otherwise.
+export function runTerraformCommand(args, cwd, spin, loadingPrefix) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('terraform', args, { cwd });
+        let errorOutput = '';
+        let isDone = false;
+
+        child.stdout.on('data', (data) => {
+            if (isDone) return;
+            const lines = data.toString().split('\n').filter(line => line.trim() !== '');
+            if (lines.length > 0) {
+                const latestLine = lines[lines.length - 1].trim();
+                const display = latestLine.length > 120 ? latestLine.substring(0, 117) + '...' : latestLine;
+                spin.message(`${loadingPrefix} - ${color.dim(display)}`);
+            }
+        });
+
+        child.stderr.on('data', (data) => {
+            errorOutput += data.toString();
+        });
+
+        child.on('close', (code) => {
+            isDone = true;
+            if (code === 0) {
+                resolve();
+            } else {
+                reject(new Error(errorOutput || `Terraform exited with code ${code}`));
+            }
+        });
+
+        child.on('error', (err) => {
+            isDone = true;
+            reject(err);
+        });
+    });
+}
+
+// Pulls JSON outputs from Terraform. Never throws: unparseable output,
+// non-zero exit, and spawn errors all resolve to an empty object.
+export function getTerraformOutputs(cwd) {
+    return new Promise((resolve) => {
+        const child = spawn('terraform', ['output', '-json'], { cwd });
+        let outputData = '';
+
+        child.stdout.on('data', (data) => {
+            outputData += data.toString();
+        });
+
+        child.on('close', (code) => {
+            if (code === 0) {
+                try {
+                    resolve(JSON.parse(outputData));
+                } catch {
+                    resolve({});
+                }
+            } else {
+                resolve({});
+            }
+        });
+
+        child.on('error', () => {
+            resolve({});
+        });
+    });
+}