@joshualiamzn/open-stack 0.0.1 → 0.0.2

package/src/cli.mjs

@@ -6,11 +6,17 @@ import { DEFAULTS } from './config.mjs';
  * Returns null when no flags were given (triggers interactive mode).
  */
 export function parseCli(argv) {
+  // No args → interactive REPL
+  if (argv.length <= 2) return null;
+
+  // Demo subcommand — separate parser to avoid option conflicts
+  if (argv[2] === 'demo') return parseDemoArgs(argv);
+
   const program = new Command()
     .name('open-stack')
     .description(
-      'Create AWS resources and an OpenSearch Ingestion (OSI) pipeline\n' +
-      'for the full Observability Stack: logs, traces, metrics, service map.'
+      'Create and manage your observability stack on AWS:\n' +
+      'OpenSearch, Prometheus, IAM roles, and ingestion pipelines.'
     )
     .version('1.0.0');
 
@@ -47,6 +53,10 @@ export function parseCli(argv) {
     .option('--prometheus-url <url>', 'Reuse an existing APS remote-write URL')
     .option('--aps-workspace-alias <name>', 'Alias for new APS workspace');
 
+  // Dashboards
+  program
+    .option('--dashboards-url <url>', 'Reuse an existing OpenSearch UI URL');
+
   // Pipeline tuning
   program
     .option('--min-ocu <n>', 'Minimum OCUs', DEFAULTS.minOcu)
@@ -59,13 +69,24 @@ export function parseCli(argv) {
     .option('--dry-run', 'Generate config only; do not create AWS resources');
 
   program.parse(argv);
-  const opts = program.opts();
 
-  // If no meaningful flags were provided, return null → interactive
-  const userArgs = argv.slice(2);
-  if (userArgs.length === 0) return null;
+  return optsToConfig(program.opts());
+}
 
-  return optsToConfig(opts);
+function parseDemoArgs(argv) {
+  const program = new Command()
+    .name('open-stack demo')
+    .description('Create an EKS cluster and install the observability stack + OTel demo')
+    .option('--cluster-name <name>', 'EKS cluster name', 'open-stack-demo')
+    .option('--region <region>', 'AWS region', process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION)
+    .option('--pipeline <name>', 'Existing OSI pipeline name to connect')
+    .option('--node-count <n>', 'Number of EKS nodes', '3')
+    .option('--instance-type <type>', 'EKS node instance type', 'm8i.large')
+    .option('--skip-otel-demo', 'Skip installing the OpenTelemetry Demo app');
+
+  program.parse(argv.slice(1));
+  const opts = program.opts();
+  return { _command: 'demo', ...opts, nodeCount: Number(opts.nodeCount) };
 }
 
 /**
@@ -87,6 +108,10 @@ function optsToConfig(opts) {
   if (opts.prometheusUrl) apsAction = 'reuse';
   else if (opts.apsWorkspaceAlias) apsAction = 'create';
 
+  let dashboardsAction = '';
+  if (opts.dashboardsUrl) dashboardsAction = 'reuse';
+  else dashboardsAction = 'create';
+
   // Auto-detect serverless from endpoint URL when not explicitly set
   if (opts.serverless && opts.managed) {
     throw new Error('--serverless and --managed are mutually exclusive');
@@ -127,6 +152,15 @@ function optsToConfig(opts) {
     minOcu: Number(opts.minOcu),
     maxOcu: Number(opts.maxOcu),
     serviceMapWindow: opts.serviceMapWindow,
+    dashboardsAction,
+    dashboardsUrl: opts.dashboardsUrl || '',
+    dqsRoleName: '',
+    dqsRoleArn: '',
+    dqsDataSourceName: '',
+    dqsDataSourceArn: '',
+    appName: '',
+    appId: '',
+    appEndpoint: '',
     outputFile: opts.output || '',
     dryRun: opts.dryRun || false,
     accountId: '',
@@ -144,6 +178,10 @@ export function applySimpleDefaults(cfg) {
   if (!cfg.iamRoleName) cfg.iamRoleName = `${cfg.pipelineName}-osi-role`;
   if (!cfg.apsAction) cfg.apsAction = 'create';
   if (!cfg.apsWorkspaceAlias) cfg.apsWorkspaceAlias = cfg.pipelineName;
+  if (!cfg.dashboardsAction) cfg.dashboardsAction = 'create';
+  if (!cfg.dqsRoleName) cfg.dqsRoleName = `${cfg.pipelineName}-dqs-prometheus-role`;
+  if (!cfg.dqsDataSourceName) cfg.dqsDataSourceName = `${cfg.pipelineName.replace(/-/g, '_')}_prometheus`;
+  if (!cfg.appName) cfg.appName = cfg.pipelineName;
 }
 
 /**
@@ -161,6 +199,15 @@ export function fillDryRunPlaceholders(cfg) {
   if (cfg.apsAction === 'create' && !cfg.prometheusUrl) {
     cfg.prometheusUrl = `https://aps-workspaces.${cfg.region}.amazonaws.com/workspaces/<workspace-id>/api/v1/remote_write`;
   }
+  if (!cfg.dqsRoleArn && cfg.dqsRoleName) {
+    cfg.dqsRoleArn = `arn:aws:iam::${cfg.accountId || '123456789012'}:role/${cfg.dqsRoleName}`;
+  }
+  if (!cfg.dqsDataSourceArn && cfg.dqsDataSourceName) {
+    cfg.dqsDataSourceArn = `arn:aws:opensearch:${cfg.region}:${cfg.accountId || '123456789012'}:datasource/${cfg.dqsDataSourceName}`;
+  }
+  if (!cfg.appEndpoint) {
+    cfg.appEndpoint = `https://<app-id>.${cfg.region}.opensearch.amazonaws.com`;
+  }
 }
 
 /**
@@ -181,6 +228,9 @@ export function validateConfig(cfg) {
   if (cfg.apsAction === 'reuse' && !cfg.prometheusUrl) {
     errors.push('--prometheus-url required when reusing APS workspace');
   }
+  if (cfg.dashboardsAction === 'reuse' && !cfg.dashboardsUrl) {
+    errors.push('--dashboards-url required when reusing OpenSearch UI');
+  }
 
   // Format checks
   if (cfg.region && !/^[a-z]{2}-[a-z]+-\d+$/.test(cfg.region)) {

package/src/commands/create.mjs

@@ -1,15 +1,188 @@
 import { runCreateWizard } from '../interactive.mjs';
-import { applySimpleDefaults, validateConfig, fillDryRunPlaceholders } from '../cli.mjs';
-import { renderPipeline } from '../render.mjs';
+import { applySimpleDefaults, validateConfig } from '../cli.mjs';
 import { executePipeline } from '../main.mjs';
-import { printError, printSuccess, printDivider, theme } from '../ui.mjs';
-import { writeFileSync } from 'node:fs';
+import { promptDemoAfterCreate } from './demo.mjs';
+import { printError, printStep, theme, GoBack, eConfirm } from '../ui.mjs';
+
+// ── Architecture diagram ────────────────────────────────────────────────────
+
+const strip = (s) => s.replace(/\x1B\[[0-9;]*m/g, '');
+
+/**
+ * Build a styled box. Returns { w, mid, inner, top, bot, botC, lines }.
+ * All strings have correct visual width thanks to ANSI-aware padding.
+ */
+function box(texts, minInner = 0) {
+  const m = theme.muted;
+  const inner = Math.max(minInner, ...texts.map((t) => strip(t).length + 2));
+  const w = inner + 2;
+  const mid = Math.floor(w / 2);
+
+  const padLine = (t) => {
+    const gap = inner - strip(t).length - 1;
+    return m('│') + ' ' + t + ' '.repeat(Math.max(0, gap)) + m('│');
+  };
+
+  return {
+    w, mid, inner,
+    top:  m('┌' + '─'.repeat(inner) + '┐'),
+    bot:  m('└' + '─'.repeat(inner) + '┘'),
+    botC: m('└' + '─'.repeat(mid - 1) + '┬' + '─'.repeat(inner - mid) + '┘'),
+    lines: texts.map(padLine),
+  };
+}
+
+/** Build a horizontal connector line in a char array, then wrap with muted style. */
+function hline(width, from, to, specs) {
+  const arr = Array(width).fill(' ');
+  for (let i = from; i <= to; i++) arr[i] = '─';
+  for (const [pos, ch] of specs) if (pos >= 0 && pos < width) arr[pos] = ch;
+  return theme.muted(arr.join('').trimEnd());
+}
+
+/** Place single characters at given positions, everything else is a space. */
+function connector(width, specs) {
+  const arr = Array(width).fill(' ');
+  for (const [pos, ch] of specs) if (pos >= 0 && pos < width) arr[pos] = ch;
+  return theme.muted(arr.join('').trimEnd());
+}
+
+function renderArchitectureDiagram(cfg) {
+  const osLabel = cfg.serverless ? 'OpenSearch Serverless' : 'OpenSearch';
+  const pathLabel = `/${cfg.pipelineName}/v1/*`;
+  const m = theme.muted;
+  const a = theme.accent;
+  const p = theme.primary;
+  const h = theme.highlight;
+  const sp = (n) => ' '.repeat(Math.max(0, n));
+
+  // ── Define all boxes ──────────────────────────────────────────────────
+  const otlp    = box([a('OSI Endpoint'), m(pathLabel)], 21);
+  const logs    = box([h('Logs')],    9);
+  const traces  = box([h('Traces')],  9);
+  const metrics = box([h('Metrics')], 9);
+  const raw     = box([m('Raw'), m('Traces')],  9);
+  const svc     = box([m('Service'), m('Map')], 9);
+  const os      = box([p(osLabel), m('logs, traces, svc-map')]);
+  const prom    = box([p('AWS Prometheus'), m('metrics, svc-map')]);
+  const dash    = box([p('OpenSearch UI'), m('Observability workspace')]);
+
+  // ── Layout positions ──────────────────────────────────────────────────
+  const sigGap  = 2;
+  const subGap  = 1;
+  const sinkGap = 1;
+
+  // Signal row — three boxes side by side (column 0 origin)
+  const C_LOGS    = logs.mid;
+  const C_TRACES  = logs.w + sigGap + traces.mid;
+  const C_METRICS = logs.w + sigGap + traces.w + sigGap + metrics.mid;
+  const totalSigW = logs.w + sigGap + traces.w + sigGap + metrics.w;
+
+  // Sub-stage row — centered under Traces
+  const subTotalW = raw.w + subGap + svc.w;
+  const subOff    = C_TRACES - Math.floor(subTotalW / 2);
+  const C_RAW     = subOff + raw.mid;
+  const C_SVC     = subOff + raw.w + subGap + svc.mid;
+
+  // OTLP — centered above Traces column
+  const otlpOff = Math.max(0, C_TRACES - otlp.mid);
+  const C_OTLP  = otlpOff + otlp.mid;
+
+  // Service-map split — symmetric fork, left into OS box, right into Prom box
+  const C_SVC_L = C_SVC - 3;
+  const C_SVC_R = C_SVC + 3;
+
+  // Diagram width (widest row)
+  const W = Math.max(totalSigW, os.w + sinkGap + prom.w);
+
+  // ── Assemble lines ────────────────────────────────────────────────────
+  const out = [''];
+
+  // OTLP box
+  out.push(sp(otlpOff) + otlp.top);
+  for (const l of otlp.lines) out.push(sp(otlpOff) + l);
+  out.push(sp(otlpOff) + otlp.botC);
+
+  // Fan-out from OTLP to three signal columns
+  out.push(hline(W, C_LOGS, C_METRICS, [
+    [C_LOGS, '┌'], [C_OTLP, '┼'], [C_TRACES, C_TRACES === C_OTLP ? '┼' : '┬'], [C_METRICS, '┐'],
+  ]));
+  out.push(connector(W, [[C_LOGS, '▼'], [C_TRACES, '▼'], [C_METRICS, '▼']]));
+
+  // Signal boxes
+  out.push([logs, traces, metrics].map((b) => b.top).join(sp(sigGap)));
+  const sigRows = Math.max(logs.lines.length, traces.lines.length, metrics.lines.length);
+  for (let r = 0; r < sigRows; r++) {
+    out.push([logs, traces, metrics].map((b) => b.lines[r] || sp(b.w)).join(sp(sigGap)));
+  }
+  out.push([logs, traces, metrics].map((b) => b.botC).join(sp(sigGap)));
+
+  // Traces fans into Raw Traces + Service Map
+  out.push(hline(W, C_RAW, C_SVC, [
+    [C_LOGS, '│'], [C_RAW, '┌'], [C_TRACES, '┴'], [C_SVC, '┐'], [C_METRICS, '│'],
+  ]));
+  out.push(connector(W, [[C_LOGS, '│'], [C_RAW, '▼'], [C_SVC, '▼'], [C_METRICS, '│']]));
+
+  // Sub-stage boxes with Logs/Metrics pipes on either side
+  const subLine = (content) =>
+    sp(C_LOGS) + m('│') + sp(subOff - C_LOGS - 1) + content + sp(C_METRICS - subOff - subTotalW) + m('│');
+
+  out.push(subLine(raw.top  + sp(subGap) + svc.top));
+  for (let r = 0; r < Math.max(raw.lines.length, svc.lines.length); r++) {
+    out.push(subLine((raw.lines[r] || sp(raw.w)) + sp(subGap) + (svc.lines[r] || sp(svc.w))));
+  }
+  out.push(subLine(raw.botC + sp(subGap) + svc.botC));
+
+  // Service-map split + merge toward sinks
+  out.push(hline(W, C_SVC_L, C_SVC_R, [
+    [C_LOGS, '│'], [C_RAW, '│'], [C_SVC_L, '┌'], [C_SVC, '┴'], [C_SVC_R, '┐'], [C_METRICS, '│'],
+  ]));
+  out.push(connector(W, [
+    [C_LOGS, '▼'], [C_RAW, '▼'], [C_SVC_L, '▼'], [C_SVC_R, '▼'], [C_METRICS, '▼'],
+  ]));
+
+  // Sink boxes
+  out.push(os.top  + sp(sinkGap) + prom.top);
+  for (let r = 0; r < Math.max(os.lines.length, prom.lines.length); r++) {
+    out.push((os.lines[r] || sp(os.w)) + sp(sinkGap) + (prom.lines[r] || sp(prom.w)));
+  }
+  const C_PROM = os.w + sinkGap + prom.mid;
+  out.push(os.botC + sp(sinkGap) + prom.botC);
+
+  // Prometheus → DQS box
+  out.push(connector(os.w + sinkGap + prom.w, [[os.mid, '│'], [C_PROM, '│']]));
+  out.push(connector(os.w + sinkGap + prom.w, [[os.mid, '│'], [C_PROM, '▼']]));
+
+  const dqs = box([p('Direct Query Service')]);
+  const dqsOff = Math.max(0, C_PROM - dqs.mid);
+  const C_DQS = dqsOff + dqs.mid;
+  const osPipe = (rest) => sp(os.mid) + m('│') + sp(dqsOff - os.mid - 1) + rest;
+  out.push(osPipe(dqs.top));
+  for (const l of dqs.lines) out.push(osPipe(l));
+  out.push(osPipe(dqs.botC));
+
+  // Merge OpenSearch + DQS → Dashboards
+  out.push(hline(dqsOff + dqs.w, os.mid, C_DQS, [
+    [os.mid, '└'], [C_DQS, '┘'],
+  ]));
+  const mergeMid = Math.floor((os.mid + C_DQS) / 2);
+  out.push(connector(dqsOff + dqs.w, [[mergeMid, '│']]));
+  out.push(connector(dqsOff + dqs.w, [[mergeMid, '▼']]));
+
+  // Dashboards box — centered under merge point
+  const dashOff = Math.max(0, mergeMid - dash.mid);
+  out.push(sp(dashOff) + dash.top);
+  for (const l of dash.lines) out.push(sp(dashOff) + l);
+  out.push(sp(dashOff) + dash.bot);
+  out.push('');
+
+  return out;
+}
 
 export async function runCreate(session) {
   console.error();
-  printDivider();
-
   const cfg = await runCreateWizard(session);
+  if (cfg === GoBack) return GoBack;
 
   // Apply simple-mode defaults
   if (!cfg.mode) cfg.mode = 'simple';
@@ -22,22 +195,31 @@ export async function runCreate(session) {
     return;
   }
 
-  // Dry-run path
-  if (cfg.dryRun) {
-    fillDryRunPlaceholders(cfg);
-    const yaml = renderPipeline(cfg);
-
-    if (cfg.outputFile) {
-      writeFileSync(cfg.outputFile, yaml + '\n');
-      printSuccess(`Pipeline YAML written to ${cfg.outputFile}`);
-    } else {
-      console.error(`  ${theme.muted('\u2500'.repeat(43))}`);
-      process.stdout.write(yaml);
-    }
+  // ── Show architecture diagram ──────────────────────────────────────────
+  printStep('Architecture');
+  const diagram = renderArchitectureDiagram(cfg);
+  for (const line of diagram) console.error(`  ${line}`);
+
+  // ── Confirm to proceed ─────────────────────────────────────────────────
+  console.error();
+  const proceed = await eConfirm({
+    message: 'Create these resources and deploy the stack?',
+    default: true,
+  });
+  if (proceed === GoBack || !proceed) {
+    console.error(`  ${theme.muted('Cancelled.')}`);
     console.error();
     return;
   }
 
   // Live path
   await executePipeline(cfg);
+
+  // Offer to create demo EKS services
+  try {
+    await promptDemoAfterCreate(session, cfg.pipelineName);
+  } catch (err) {
+    // Demo is optional — don't fail the create flow
+    console.error(`  ${theme.muted(`Demo setup skipped: ${err.message}`)}`);
+  }
 }

package/src/commands/demo.mjs

@@ -0,0 +1,193 @@
+import {
+  printStep, printInfo, printBox, printWarning,
+  theme, GoBack, STAR, eSelect, eInput, eConfirm, createSpinner,
+} from '../ui.mjs';
+import { listPipelines, getPipelineEndpoint } from '../aws.mjs';
+import { checkDemoPrerequisites, createEksCluster, installHelmChart, installOtelDemo } from '../eks.mjs';
+
+const DEMO_DEFAULTS = {
+  clusterName: 'open-stack-demo',
+  nodeCount: 3,
+  instanceType: 'm8i.large',
+};
+
+/**
+ * Prompt user to select an OSI pipeline. Returns { pipelineName, otlpEndpoint } or GoBack.
+ */
+async function selectPipeline(region) {
+  const spinner = createSpinner('Loading pipelines...');
+  spinner.start();
+
+  let pipelines;
+  try {
+    pipelines = await listPipelines(region);
+    spinner.succeed(`${pipelines.length} pipeline${pipelines.length !== 1 ? 's' : ''} found`);
+  } catch (err) {
+    spinner.fail('Failed to list pipelines');
+    throw err;
+  }
+
+  const active = pipelines.filter((p) => p.status === 'ACTIVE');
+  if (active.length === 0) {
+    printWarning('No active OSI pipelines found. Create one first.');
+    return null;
+  }
+
+  const choice = await eSelect({
+    message: 'Select OSI pipeline to connect',
+    choices: active.map((p) => ({
+      name: `${theme.accent(p.name)}  ${theme.muted(p.status)}`,
+      value: p.name,
+    })),
+  });
+  if (choice === GoBack) return GoBack;
+
+  const endpointSpinner = createSpinner('Getting pipeline endpoint...');
+  endpointSpinner.start();
+  try {
+    const endpoint = await getPipelineEndpoint(region, choice);
+    endpointSpinner.succeed(`Endpoint: ${endpoint}`);
+    return { pipelineName: choice, otlpEndpoint: endpoint };
+  } catch (err) {
+    endpointSpinner.fail('Failed to get pipeline endpoint');
+    throw err;
+  }
+}
+
+/**
+ * Run the demo services command — creates an EKS cluster and installs
+ * the observability stack Helm chart with demo applications.
+ */
+export async function runDemo(session) {
+  console.error();
+  printStep('Install Demo');
+  printInfo('Creates an EKS cluster and installs the observability stack Helm chart with demo applications');
+  printInfo(`Default config: ${DEMO_DEFAULTS.nodeCount} x ${DEMO_DEFAULTS.instanceType} nodes`);
+  console.error();
+
+  // Collect cluster name
+  const clusterName = await eInput({
+    message: 'EKS cluster name',
+    default: DEMO_DEFAULTS.clusterName,
+    validate: (v) => v.trim().length > 0 || 'Cluster name is required',
+  });
+  if (clusterName === GoBack) return GoBack;
+
+  // Select OSI pipeline to connect
+  const pipeline = await selectPipeline(session.region);
+  if (pipeline === GoBack) return GoBack;
+  if (!pipeline) return;
+
+  const { nodeCount, instanceType } = DEMO_DEFAULTS;
+
+  // Confirm
+  console.error();
+  printInfo(`Cluster: ${theme.accent(clusterName)} | Nodes: ${theme.accent(String(nodeCount))} x ${theme.accent(instanceType)} | Region: ${theme.accent(session.region)}`);
+  printInfo(`Pipeline: ${theme.accent(pipeline.pipelineName)}`);
+  console.error();
+
+  const proceed = await eConfirm({
+    message: 'Create EKS cluster and install demo services?',
+    default: true,
+  });
+  if (proceed === GoBack || !proceed) {
+    console.error(`  ${theme.muted('Cancelled.')}`);
+    console.error();
+    return;
+  }
+
+  // Execute
+  console.error();
+  checkDemoPrerequisites();
+  await createEksCluster({
+    clusterName,
+    region: session.region,
+    nodeCount,
+    instanceType,
+    stackName: pipeline.pipelineName,
+    accountId: session.accountId,
+  });
+  console.error();
+  await installHelmChart({ otlpEndpoint: pipeline.otlpEndpoint });
+  console.error();
+  await installOtelDemo({ otlpEndpoint: pipeline.otlpEndpoint });
+  console.error();
+
+  printBox([
+    '',
+    `${theme.success.bold(`${STAR} Demo Services Deployed! ${STAR}`)}`,
+    '',
+    `${theme.label('Cluster:')}    ${clusterName}`,
+    `${theme.label('Region:')}     ${session.region}`,
+    `${theme.label('Nodes:')}      ${nodeCount} x ${instanceType}`,
+    `${theme.label('Pipeline:')}   ${pipeline.pipelineName}`,
+    `${theme.label('Namespace:')}  observability`,
+    `${theme.label('Release:')}    obs-stack`,
+    '',
+    `${theme.muted('Check pods:')}      kubectl get pods -n observability`,
+    `${theme.muted('OTel Demo pods:')}  kubectl get pods -n otel-demo`,
+    `${theme.muted('Dashboards:')}      kubectl port-forward svc/obs-stack-opensearch-dashboards 5601:5601 -n observability`,
+    `${theme.muted('Demo Frontend:')}   kubectl port-forward svc/otel-demo-frontend-proxy 8080:8080 -n otel-demo`,
+    '',
+  ], { color: 'primary', padding: 2 });
+}
+
+/**
+ * Prompt the user to optionally create demo EKS services after stack creation.
+ * When called from the create flow, pipelineName is the pipeline just created.
+ * Returns true if demo was created, false if skipped.
+ */
+export async function promptDemoAfterCreate(session, pipelineName) {
+  console.error();
+  const wantDemo = await eConfirm({
+    message: 'Would you like to install demo EKS services?',
+    default: false,
+  });
+
+  if (wantDemo === GoBack || !wantDemo) return false;
+
+  console.error();
+  const clusterName = await eInput({
+    message: 'EKS cluster name',
+    default: DEMO_DEFAULTS.clusterName,
+    validate: (v) => v.trim().length > 0 || 'Cluster name is required',
+  });
+  if (clusterName === GoBack) return false;
+
+  console.error();
+  checkDemoPrerequisites();
+
+  // Get the OTLP endpoint for the just-created pipeline
+  let otlpEndpoint;
+  try {
+    otlpEndpoint = await getPipelineEndpoint(session.region, pipelineName);
+    if (otlpEndpoint) {
+      printInfo(`Using pipeline: ${theme.accent(pipelineName)}`);
+      printInfo(`OTLP endpoint: ${theme.accent(otlpEndpoint)}`);
+    }
+  } catch {
+    printWarning('Could not get pipeline endpoint — Helm chart will use default config');
+  }
+
+  const { nodeCount, instanceType } = DEMO_DEFAULTS;
+
+  console.error();
+  await createEksCluster({
+    clusterName,
+    region: session.region,
+    nodeCount,
+    instanceType,
+    stackName: pipelineName,
+    accountId: session.accountId,
+  });
+  console.error();
+  await installHelmChart({ otlpEndpoint });
+  console.error();
+  await installOtelDemo({ otlpEndpoint });
+  console.error();
+
+  printInfo(`Demo services deployed. Check: kubectl get pods -n observability`);
+  printInfo(`OTel Demo pods: kubectl get pods -n otel-demo`);
+  printInfo(`Demo Frontend: kubectl port-forward svc/otel-demo-frontend-proxy 8080:8080 -n otel-demo`);
+  return true;
+}

package/src/commands/describe.mjs

@@ -1,71 +1,81 @@
-import { select } from '@inquirer/prompts';
-import { getPipeline } from '../aws.mjs';
-import { printInfo, printPanel, printBox, createSpinner, colorStatus, formatDate, theme } from '../ui.mjs';
-import { loadPipelines } from './index.mjs';
+import { getStackResources, arnToName, describeResource, enrichResourceNames } from '../aws.mjs';
+import { printInfo, createSpinner, printPanel, theme, GoBack, eSelect } from '../ui.mjs';
+import { loadStacks } from './index.mjs';
 
 export async function runDescribe(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;
   }
 
-  // Select a pipeline
-  const choices = pipelines.map((p) => ({
-    name: `${p.name}  ${theme.muted(`(${p.status})`)}`,
-    value: p.name,
+  // Select a stack
+  const choices = stacks.map((s) => ({
+    name: `${s.name}  ${theme.muted(`(${s.resources.length} resources)`)}`,
+    value: s.name,
   }));
 
-  const pipelineName = await select({
-    message: 'Select pipeline',
+  const stackName = await eSelect({
+    message: 'Select stack',
     choices,
   });
+  if (stackName === GoBack) return GoBack;
 
-  // Fetch full details
-  const detailSpinner = createSpinner(`Loading ${pipelineName}...`);
+  // Fetch full resource list
+  const detailSpinner = createSpinner(`Loading ${stackName}...`);
   detailSpinner.start();
 
-  let pipeline;
+  let resources;
   try {
-    pipeline = await getPipeline(session.region, pipelineName);
-    detailSpinner.succeed(`Pipeline: ${pipelineName}`);
+    resources = await getStackResources(session.region, stackName);
+    await enrichResourceNames(session.region, resources);
+    detailSpinner.succeed(`Stack: ${stackName} (${resources.length} resources)`);
   } catch (err) {
-    detailSpinner.fail('Failed to get pipeline details');
+    detailSpinner.fail('Failed to get stack details');
     throw err;
   }
 
-  // Display details in a panel
-  console.error();
-  const entries = [
-    ['Name', pipeline.name],
-    ['ARN', theme.muted(pipeline.arn)],
-    ['Status', colorStatus(pipeline.status)],
-  ];
-  if (pipeline.statusReason) {
-    entries.push(['Status Reason', pipeline.statusReason]);
-  }
-  entries.push(
-    ['Min OCUs', String(pipeline.minUnits)],
-    ['Max OCUs', String(pipeline.maxUnits)],
-    ['Created', formatDate(pipeline.createdAt)],
-    ['Last Updated', formatDate(pipeline.lastUpdatedAt)],
-  );
-  printPanel(pipelineName, entries);
+  const resName = (r) => r.displayName || arnToName(r.arn);
 
-  if (pipeline.ingestEndpoints.length > 0) {
+  // Resource selection loop
+  while (true) {
     console.error();
-    const epLines = pipeline.ingestEndpoints.map((ep) => theme.accent(ep));
-    printBox(['', ...epLines, ''], { title: 'Ingestion Endpoints', color: 'dim', padding: 2 });
-  }
+    const resourceChoices = resources.map((r) => ({
+      name: `${theme.accentBold(r.type)}  ${theme.muted(resName(r))}`,
+      value: r,
+    }));
+
+    const selected = await eSelect({
+      message: 'Select resource',
+      choices: resourceChoices,
+    });
+    if (selected === GoBack) break;
+
+    // Fetch and display resource details
+    const resSpinner = createSpinner(`Loading ${selected.type}...`);
+    resSpinner.start();
+
+    let result;
+    try {
+      result = await describeResource(session.region, selected);
+      resSpinner.succeed(`${selected.type}: ${resName(selected)}`);
+    } catch (err) {
+      resSpinner.fail(`Failed to describe ${selected.type}`);
+      continue;
+    }
 
-  if (pipeline.pipelineConfigurationBody) {
     console.error();
-    const configLines = pipeline.pipelineConfigurationBody.split('\n').map((l) => theme.muted(l));
-    printBox(['', ...configLines, ''], { title: 'Pipeline Configuration', color: 'dim', padding: 1 });
+    const panelEntries = result.entries.map(([label, value]) => [label, theme.muted(value)]);
+    printPanel(resName(selected), panelEntries);
+
+    if (result.rawConfig) {
+      console.error();
+      console.error(theme.muted(result.rawConfig));
+    }
   }
 
   console.error();