@joshualiamzn/open-stack 0.0.1 → 0.0.2

package/src/commands/help.mjs

@@ -4,16 +4,15 @@ export async function runHelp() {
   console.error();
   const lines = [
     '',
-    `${theme.accentBold('create')}      Create a new OSI pipeline (interactive wizard)`,
-    `${theme.accentBold('list')}        List existing OSI pipelines`,
-    `${theme.accentBold('describe')}    Show details of a specific pipeline`,
-    `${theme.accentBold('update')}      Update an existing pipeline's settings`,
+    `${theme.accentBold('create')}      Create a new observability stack`,
+    `${theme.accentBold('list')}        List existing stacks`,
+    `${theme.accentBold('describe')}    Show details of a stack`,
     `${theme.accentBold('help')}        Show this help message`,
-    `${theme.accentBold('quit')}        Exit the pipeline manager`,
+    `${theme.accentBold('quit')}        Exit Open Stack`,
     '',
   ];
   printBox(lines, { title: 'Commands', color: 'dim', padding: 2 });
   console.error();
-  printKeyHint([['Ctrl+C', 'cancel any operation and return to menu']]);
+  printKeyHint([['Ctrl+C', 'exit']]);
   console.error();
 }

package/src/commands/index.mjs

@@ -1,23 +1,22 @@
 import { runCreate } from './create.mjs';
 import { runList } from './list.mjs';
 import { runDescribe } from './describe.mjs';
-import { runUpdate } from './update.mjs';
-import { runHelp } from './help.mjs';
-import { listPipelines } from '../aws.mjs';
+import { runDemo } from './demo.mjs';
+import { listStacks } from '../aws.mjs';
 import { createSpinner, theme } from '../ui.mjs';
 
 /**
- * Load pipelines with a spinner. Shared by describe, list, and update commands.
+ * Load stacks with a spinner. Shared by describe and list commands.
  */
-export async function loadPipelines(region) {
-  const spinner = createSpinner('Loading pipelines...');
+export async function loadStacks(region) {
+  const spinner = createSpinner('Loading stacks...');
   spinner.start();
   try {
-    const pipelines = await listPipelines(region);
-    spinner.succeed(`${pipelines.length} pipeline${pipelines.length !== 1 ? 's' : ''} found`);
-    return pipelines;
+    const stacks = await listStacks(region);
+    spinner.succeed(`${stacks.length} stack${stacks.length !== 1 ? 's' : ''} found`);
+    return stacks;
   } catch (err) {
-    spinner.fail('Failed to list pipelines');
+    spinner.fail('Failed to list stacks');
     throw err;
   }
 }
@@ -26,15 +25,13 @@ export const COMMANDS = {
   create: runCreate,
   list: runList,
   describe: runDescribe,
-  update: runUpdate,
-  help: runHelp,
+  demo: runDemo,
 };
 
 export const COMMAND_CHOICES = [
-  { name: `\u2728 Create    ${theme.muted('Create a new OSI pipeline')}`, value: 'create' },
-  { name: `\u2630  List      ${theme.muted('List existing pipelines')}`, value: 'list' },
-  { name: `\uD83D\uDD0D Describe  ${theme.muted('Show details of a pipeline')}`, value: 'describe' },
-  { name: `\u270E  Update    ${theme.muted('Update a pipeline')}`, value: 'update' },
-  { name: `\u2753 Help      ${theme.muted('Show available commands')}`, value: 'help' },
+  { name: `\u2728 Create    ${theme.muted('Create a new observability stack')}`, value: 'create' },
+  { name: `\u2630 List      ${theme.muted('List existing stacks')}`, value: 'list' },
+  { name: `\uD83D\uDD0D Describe  ${theme.muted('Show details of a stack')}`, value: 'describe' },
+  { name: `\uD83D\uDE80 Install Demo ${theme.muted('Create demo services on EKS')}`, value: 'demo' },
   { name: `\uD83D\uDEAA Quit      ${theme.muted('Exit')}`, value: 'quit' },
 ];

package/src/commands/list.mjs

@@ -1,26 +1,27 @@
-import { printTable, printInfo, colorStatus, formatDate } from '../ui.mjs';
-import { loadPipelines } from './index.mjs';
+import { printTable, printInfo, theme } from '../ui.mjs';
+import { loadStacks } from './index.mjs';
 
 export async function runList(session) {
   console.error();
 
-  const pipelines = await loadPipelines(session.region);
+  const stacks = await loadStacks(session.region);
 
-  if (pipelines.length === 0) {
-    printInfo('No OSI pipelines found in this region.');
+  if (stacks.length === 0) {
+    printInfo('No open-stack stacks found in this region.');
     console.error();
     return;
   }
 
   console.error();
-  const headers = ['Name', 'Status', 'OCUs', 'Created', 'Updated'];
-  const rows = pipelines.map((p) => [
-    p.name,
-    colorStatus(p.status),
-    `${p.minUnits}\u2013${p.maxUnits}`,
-    formatDate(p.createdAt),
-    formatDate(p.lastUpdatedAt),
-  ]);
+  const headers = ['Stack', 'Resources', 'Types'];
+  const rows = stacks.map((s) => {
+    const types = [...new Set(s.resources.map((r) => r.type))];
+    return [
+      s.name,
+      String(s.resources.length),
+      types.join(theme.muted(', ')),
+    ];
+  });
 
   printTable(headers, rows);
 }

package/src/config.mjs

@@ -2,7 +2,7 @@
  * Default configuration values.
  */
 export const DEFAULTS = {
-  pipelineName: 'observability-stack',
+  pipelineName: `open-stack-${Math.floor(Date.now() / 1000)}`,
   osInstanceType: 'r6g.large.search',
   osInstanceCount: 1,
   osVolumeSize: 100,
@@ -38,6 +38,16 @@ export function createDefaultConfig() {
     minOcu: DEFAULTS.minOcu,
     maxOcu: DEFAULTS.maxOcu,
     serviceMapWindow: DEFAULTS.serviceMapWindow,
+    dashboardsAction: '',
+    dashboardsUrl: '',
+    dqsRoleName: '',
+    dqsRoleArn: '',
+    dqsDataSourceName: '',
+    dqsDataSourceArn: '',
+    appName: '',
+    appId: '',
+    appEndpoint: '',
+    ingestEndpoints: [],
     outputFile: '',
     dryRun: false,
     accountId: '',

package/src/eks.mjs

@@ -0,0 +1,356 @@
+import { execSync, spawn } from 'node:child_process';
+import { mkdtempSync, rmSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  printStep,
+  printSuccess,
+  printError,
+  printWarning,
+  printInfo,
+  createSpinner,
+} from './ui.mjs';
+import { tagResource } from './aws.mjs';
+import chalk from 'chalk';
+
+const HELM_CHART_REPO = 'https://github.com/kylehounslow/observability-stack.git';
+const HELM_CHART_BRANCH = 'feat/helm-charts';
+const HELM_CHART_PATH = 'charts/observability-stack';
+const HELM_RELEASE_NAME = 'obs-stack';
+const HELM_NAMESPACE = 'observability';
+
+const OTEL_DEMO_REPO = 'https://open-telemetry.github.io/opentelemetry-helm-charts';
+const OTEL_DEMO_RELEASE_NAME = 'otel-demo';
+const OTEL_DEMO_NAMESPACE = 'otel-demo';
+
+// ── Prerequisites ───────────────────────────────────────────────────────────
+
+function commandExists(cmd) {
+  try {
+    execSync(`command -v ${cmd}`, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function checkDemoPrerequisites() {
+  printStep('Checking demo prerequisites...');
+  console.error();
+
+  const required = [
+    { cmd: 'aws', install: 'https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html' },
+    { cmd: 'eksctl', install: 'https://eksctl.io/installation/' },
+    { cmd: 'kubectl', install: 'https://kubernetes.io/docs/tasks/tools/' },
+    { cmd: 'helm', install: 'https://helm.sh/docs/intro/install/' },
+    { cmd: 'git', install: 'https://git-scm.com/downloads' },
+  ];
+
+  const missing = [];
+  for (const { cmd, install } of required) {
+    if (commandExists(cmd)) {
+      printSuccess(`${cmd} found`);
+    } else {
+      missing.push({ cmd, install });
+      printError(`${cmd} not found`);
+    }
+  }
+
+  if (missing.length > 0) {
+    console.error();
+    console.error(`  ${chalk.bold('Missing required tools:')}`);
+    for (const { cmd, install } of missing) {
+      console.error(`    ${chalk.bold(cmd)}: ${chalk.underline(install)}`);
+    }
+    console.error();
+    process.exit(1);
+  }
+
+  console.error();
+}
+
+// ── EKS Cluster ─────────────────────────────────────────────────────────────
+
+function runCommand(cmd, args, { spinner, prefix = '' } = {}) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(cmd, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env },
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout.on('data', (data) => {
+      stdout += data.toString();
+      const lines = data.toString().trim().split('\n');
+      for (const line of lines) {
+        if (spinner && line.trim()) {
+          spinner.text = `${prefix}${line.trim()}`;
+        }
+      }
+    });
+
+    proc.stderr.on('data', (data) => {
+      stderr += data.toString();
+      const lines = data.toString().trim().split('\n');
+      for (const line of lines) {
+        if (spinner && line.trim()) {
+          spinner.text = `${prefix}${line.trim()}`;
+        }
+      }
+    });
+
+    proc.on('close', (code) => {
+      if (code === 0) {
+        resolve(stdout.trim());
+      } else {
+        reject(new Error(stderr.trim() || `Command failed with exit code ${code}`));
+      }
+    });
+
+    proc.on('error', reject);
+  });
+}
+
+export async function createEksCluster(cfg) {
+  const { clusterName, region, nodeCount, instanceType, stackName, accountId } = cfg;
+
+  printStep(`Creating EKS cluster '${clusterName}'...`);
+  console.error();
+
+  // Check if cluster already exists
+  try {
+    const existing = execSync(
+      `eksctl get cluster --name ${clusterName} --region ${region} 2>/dev/null`,
+      { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] },
+    );
+    if (existing.includes(clusterName)) {
+      printSuccess(`Cluster '${clusterName}' already exists`);
+      printInfo('Updating kubeconfig...');
+      execSync(
+        `aws eks update-kubeconfig --name ${clusterName} --region ${region}`,
+        { stdio: 'ignore' },
+      );
+      printSuccess('kubeconfig updated');
+      return;
+    }
+  } catch { /* cluster doesn't exist — proceed to create */ }
+
+  const spinner = createSpinner('Creating EKS cluster (15-25 min)...');
+  spinner.start();
+
+  try {
+    await runCommand('eksctl', [
+      'create', 'cluster',
+      '--name', clusterName,
+      '--region', region,
+      '--nodes', String(nodeCount),
+      '--node-type', instanceType,
+      '--managed',
+    ], { spinner, prefix: 'EKS: ' });
+
+    spinner.succeed(`Cluster '${clusterName}' created`);
+  } catch (err) {
+    spinner.fail('Failed to create EKS cluster');
+    console.error();
+    console.error(`  ${chalk.dim(err.message)}`);
+    console.error();
+    throw new Error('Failed to create EKS cluster');
+  }
+
+  // Tag the EKS cluster for stack discovery
+  if (stackName && accountId) {
+    const clusterArn = `arn:aws:eks:${region}:${accountId}:cluster/${clusterName}`;
+    await tagResource(region, clusterArn, stackName);
+    printSuccess('Cluster tagged');
+  }
+
+  // Update kubeconfig
+  try {
+    execSync(
+      `aws eks update-kubeconfig --name ${clusterName} --region ${region}`,
+      { stdio: 'ignore' },
+    );
+    printSuccess('kubeconfig updated');
+  } catch (err) {
+    printWarning(`Could not update kubeconfig: ${err.message}`);
+    printInfo(`Run: aws eks update-kubeconfig --name ${clusterName} --region ${region}`);
+  }
+}
+
+// ── Helm Chart Installation ─────────────────────────────────────────────────
+
+export async function installHelmChart(cfg) {
+  printStep('Installing observability stack Helm chart...');
+  console.error();
+
+  const tmpDir = mkdtempSync(join(tmpdir(), 'obs-stack-'));
+  const chartDir = join(tmpDir, 'observability-stack', HELM_CHART_PATH);
+
+  try {
+    // Clone the chart repo
+    const cloneSpinner = createSpinner('Cloning Helm chart repository...');
+    cloneSpinner.start();
+
+    try {
+      await runCommand('git', [
+        'clone',
+        '--branch', HELM_CHART_BRANCH,
+        '--depth', '1',
+        HELM_CHART_REPO,
+        join(tmpDir, 'observability-stack'),
+      ], { spinner: cloneSpinner });
+      cloneSpinner.succeed('Chart repository cloned');
+    } catch (err) {
+      cloneSpinner.fail('Failed to clone chart repository');
+      console.error(`  ${chalk.dim(err.message)}`);
+      throw new Error('Failed to clone Helm chart repository');
+    }
+
+    // Patch: remove duplicate data-prepper metrics port (4900).
+    // The subchart template hardcodes a "server" port on 4900, so having
+    // "metrics: 4900" in values.yaml causes a duplicate port warning.
+    try {
+      const valuesPath = join(chartDir, 'values.yaml');
+      const values = readFileSync(valuesPath, 'utf-8');
+      writeFileSync(valuesPath, values.replace(/^\s*- name: metrics\n\s*port: 4900\n/m, ''));
+    } catch { /* best effort — chart may have been fixed upstream */ }
+
+    // Build dependencies
+    const depSpinner = createSpinner('Building Helm dependencies...');
+    depSpinner.start();
+
+    try {
+      await runCommand('helm', ['dependency', 'build', chartDir], { spinner: depSpinner });
+      depSpinner.succeed('Helm dependencies built');
+    } catch (err) {
+      depSpinner.fail('Failed to build Helm dependencies');
+      console.error(`  ${chalk.dim(err.message)}`);
+      throw new Error('Failed to build Helm dependencies');
+    }
+
+    // Install chart
+    const installSpinner = createSpinner('Installing Helm chart (this may take a few minutes)...');
+    installSpinner.start();
+
+    const helmArgs = [
+      'install', HELM_RELEASE_NAME, chartDir,
+      '--namespace', HELM_NAMESPACE,
+      '--create-namespace',
+      '--wait',
+      '--timeout', '20m',
+    ];
+
+    // If the stack config has an OTLP endpoint, pass it as a value override
+    if (cfg.otlpEndpoint) {
+      helmArgs.push('--set', `opentelemetry-collector.config.exporters.otlp/osi.endpoint=${cfg.otlpEndpoint}`);
+    }
+
+    try {
+      await runCommand('helm', helmArgs, { spinner: installSpinner });
+      installSpinner.succeed('Helm chart installed');
+    } catch (err) {
+      // Check if release already exists
+      if (/already exists/i.test(err.message) || /cannot re-use/i.test(err.message)) {
+        installSpinner.succeed(`Release '${HELM_RELEASE_NAME}' already installed`);
+        printInfo(`To upgrade: helm upgrade ${HELM_RELEASE_NAME} ${chartDir} -n ${HELM_NAMESPACE}`);
+        return;
+      }
+      installSpinner.fail('Failed to install Helm chart');
+      console.error(`  ${chalk.dim(err.message)}`);
+      throw new Error('Failed to install Helm chart');
+    }
+
+    // Show deployment status
+    console.error();
+    printSuccess('Demo services deployed to EKS');
+    printInfo(`Namespace: ${HELM_NAMESPACE}`);
+    printInfo(`Release: ${HELM_RELEASE_NAME}`);
+    printInfo(`Check status: kubectl get pods -n ${HELM_NAMESPACE}`);
+  } finally {
+    // Clean up temp directory
+    try {
+      rmSync(tmpDir, { recursive: true, force: true });
+    } catch { /* best effort cleanup */ }
+  }
+}
+
+// ── OpenTelemetry Demo ────────────────────────────────────────────────────
+
+export async function installOtelDemo(cfg) {
+  printStep('Installing OpenTelemetry Demo...');
+  console.error();
+
+  // Add the Helm repo
+  const repoSpinner = createSpinner('Adding OpenTelemetry Helm repo...');
+  repoSpinner.start();
+
+  try {
+    await runCommand('helm', [
+      'repo', 'add', 'open-telemetry', OTEL_DEMO_REPO,
+    ], { spinner: repoSpinner });
+    await runCommand('helm', ['repo', 'update'], { spinner: repoSpinner });
+    repoSpinner.succeed('OpenTelemetry Helm repo added');
+  } catch (err) {
+    // Repo may already exist — try update anyway
+    try {
+      await runCommand('helm', ['repo', 'update'], { spinner: repoSpinner });
+      repoSpinner.succeed('OpenTelemetry Helm repo updated');
+    } catch (updateErr) {
+      repoSpinner.fail('Failed to add Helm repo');
+      console.error(`  ${chalk.dim(updateErr.message)}`);
+      throw new Error('Failed to add OpenTelemetry Helm repo');
+    }
+  }
+
+  // Install the OpenTelemetry Demo chart
+  const installSpinner = createSpinner('Installing OpenTelemetry Demo (this may take a few minutes)...');
+  installSpinner.start();
+
+  const helmArgs = [
+    'install', OTEL_DEMO_RELEASE_NAME, 'open-telemetry/opentelemetry-demo',
+    '--namespace', OTEL_DEMO_NAMESPACE,
+    '--create-namespace',
+    '--wait',
+    '--timeout', '10m',
+    // Disable the demo's built-in observability backends — we use our own stack
+    '--set', 'opensearch.enabled=false',
+    '--set', 'grafana.enabled=false',
+    '--set', 'prometheus.enabled=false',
+    '--set', 'jaeger.enabled=false',
+  ];
+
+  // Point the demo's collector at the observability stack's collector
+  if (cfg.otlpEndpoint) {
+    helmArgs.push(
+      '--set', `opentelemetry-collector.config.exporters.otlp/osi.endpoint=${cfg.otlpEndpoint}`,
+    );
+  } else {
+    // Default: send to the obs-stack collector in the observability namespace
+    helmArgs.push(
+      '--set', `default.env[0].name=OTEL_EXPORTER_OTLP_ENDPOINT`,
+      '--set', `default.env[0].value=http://${HELM_RELEASE_NAME}-opentelemetry-collector.${HELM_NAMESPACE}:4317`,
+    );
+  }
+
+  try {
+    await runCommand('helm', helmArgs, { spinner: installSpinner });
+    installSpinner.succeed('OpenTelemetry Demo installed');
+  } catch (err) {
+    if (/already exists/i.test(err.message) || /cannot re-use/i.test(err.message)) {
+      installSpinner.succeed(`Release '${OTEL_DEMO_RELEASE_NAME}' already installed`);
+      return;
+    }
+    installSpinner.fail('Failed to install OpenTelemetry Demo');
+    console.error(`  ${chalk.dim(err.message)}`);
+    throw new Error('Failed to install OpenTelemetry Demo');
+  }
+
+  console.error();
+  printSuccess('OpenTelemetry Demo deployed');
+  printInfo(`Namespace: ${OTEL_DEMO_NAMESPACE}`);
+  printInfo(`Release: ${OTEL_DEMO_RELEASE_NAME}`);
+  printInfo(`Check status: kubectl get pods -n ${OTEL_DEMO_NAMESPACE}`);
+  printInfo(`Frontend: kubectl port-forward svc/${OTEL_DEMO_RELEASE_NAME}-frontend-proxy 8080:8080 -n ${OTEL_DEMO_NAMESPACE}`);
+}