@monster-orange/den 0.0.0 → 0.2.0

package/src/ui/cli/results-viewer.ts

@@ -0,0 +1,436 @@
+/**
+ * Results Viewer
+ * Display test results in CLI
+ */
+
+import Table from "cli-table3";
+import chalk from "chalk";
+import { resultReader } from "../../shared/results/result-reader.js";
+import type {
+  Pillar,
+  Environment,
+  TestResult,
+} from "../../shared/types/index.js";
+
+/** Journeys row metadata extracted from the JSONL row (all optional on the wire). */
+interface JourneyRowMetadata {
+  failureKind: string | null;
+  frictionCount: number;
+  snapshotCount: number;
+  snapshotsDir: string | null;
+}
+
+export class ResultsViewer {
+  /**
+   * Display summary of recent results
+   */
+  async displaySummary(days: number = 7): Promise<void> {
+    console.log(chalk.bold(`\n📊 Test Results Summary (Last ${days} days)`));
+    console.log(chalk.gray("━".repeat(80)));
+
+    const pillars: Pillar[] = [
+      "synthetic",
+      "integration",
+      "performance",
+      "journeys",
+      "security",
+    ];
+    const environments: Environment[] = ["local", "dev", "sandbox", "staging"];
+
+    for (const pillar of pillars) {
+      console.log(chalk.bold(`\n${this.formatPillarName(pillar)}:`));
+
+      const table = new Table({
+        head: [
+          chalk.cyan("Environment"),
+          chalk.cyan("Total"),
+          chalk.green("Passed"),
+          chalk.red("Failed"),
+          chalk.yellow("Skipped"),
+          chalk.blue("Pass Rate"),
+        ],
+        style: {
+          head: [],
+          border: ["gray"],
+        },
+      });
+
+      for (const env of environments) {
+        const summary = await resultReader.getSummary(pillar, env, days);
+
+        if (summary.total === 0) {
+          continue; // Skip environments with no results
+        }
+
+        table.push([
+          this.formatEnvironmentName(env),
+          summary.total.toString(),
+          chalk.green(summary.passed.toString()),
+          summary.failed > 0
+            ? chalk.red(summary.failed.toString())
+            : chalk.gray("0"),
+          summary.skipped > 0
+            ? chalk.yellow(summary.skipped.toString())
+            : chalk.gray("0"),
+          this.formatPassRate(summary.passRate),
+        ]);
+      }
+
+      if (table.length === 0) {
+        console.log(chalk.gray("  No results found"));
+      } else {
+        console.log(table.toString());
+      }
+    }
+
+    console.log(); // Empty line at end
+  }
+
+  /**
+   * Display detailed results for specific pillar/environment
+   */
+  async displayDetailed(
+    pillar: Pillar,
+    environment: Environment,
+    days: number = 7,
+  ): Promise<void> {
+    if (pillar === "journeys") {
+      return this.displayJourneysDetailed(environment, days);
+    }
+
+    console.log(
+      chalk.bold(
+        `\n📋 Detailed Results: ${this.formatPillarName(pillar)} / ${this.formatEnvironmentName(environment)}`,
+      ),
+    );
+    console.log(chalk.gray("━".repeat(80)));
+
+    const dateFrom = new Date();
+    dateFrom.setDate(dateFrom.getDate() - days);
+
+    const results = await resultReader.query({ pillar, environment, dateFrom });
+
+    if (results.length === 0) {
+      console.log(chalk.yellow("No results found"));
+      return;
+    }
+
+    const table = new Table({
+      head: [
+        chalk.cyan("Test"),
+        chalk.cyan("Status"),
+        chalk.cyan("Duration"),
+        chalk.cyan("User"),
+        chalk.cyan("Time"),
+      ],
+      colWidths: [40, 10, 12, 20, 20],
+      style: {
+        head: [],
+        border: ["gray"],
+      },
+      wordWrap: true,
+    });
+
+    // Show only recent 20 results
+    const recentResults = results.slice(0, 20);
+
+    for (const result of recentResults) {
+      table.push([
+        this.truncate(result.test, 38),
+        this.formatStatus(result.status),
+        this.formatDuration(result.duration),
+        this.truncate(result.user, 18),
+        this.formatTimestamp(result.timestamp),
+      ]);
+    }
+
+    console.log(table.toString());
+
+    if (results.length > 20) {
+      console.log(chalk.gray(`\n... and ${results.length - 20} more results`));
+    }
+
+    // Show summary
+    const summary = await resultReader.getSummary(pillar, environment, days);
+    console.log(chalk.bold("\nSummary:"));
+    console.log(`  Total:     ${summary.total}`);
+    console.log(`  ${chalk.green("Passed:")}   ${summary.passed}`);
+    console.log(`  ${chalk.red("Failed:")}   ${summary.failed}`);
+    console.log(`  ${chalk.yellow("Skipped:")}  ${summary.skipped}`);
+    console.log(`  Pass Rate: ${this.formatPassRate(summary.passRate)}`);
+    console.log();
+  }
+
+  /**
+   * Display journeys results — one row per journey run from the JSONL
+   * rows, surfacing the deterministic verdict, failure_kind, friction
+   * count, and the snapshots directory for the run.
+   */
+  async displayJourneysDetailed(
+    environment: Environment,
+    days: number = 7,
+  ): Promise<void> {
+    console.log(
+      chalk.bold(
+        `\n🧭 Journey Results: ${this.formatEnvironmentName(environment)}`,
+      ),
+    );
+    console.log(chalk.gray("━".repeat(80)));
+
+    const dateFrom = new Date();
+    dateFrom.setDate(dateFrom.getDate() - days);
+
+    const results = await resultReader.query({
+      pillar: "journeys",
+      environment,
+      dateFrom,
+    });
+
+    if (results.length === 0) {
+      console.log(chalk.yellow("No results found"));
+      return;
+    }
+
+    const table = new Table({
+      head: [
+        chalk.cyan("Journey"),
+        chalk.cyan("Verdict"),
+        chalk.cyan("Failure kind"),
+        chalk.cyan("Friction"),
+        chalk.cyan("Snapshots"),
+        chalk.cyan("Time"),
+      ],
+      style: {
+        head: [],
+        border: ["gray"],
+      },
+      wordWrap: true,
+    });
+
+    const recentResults = results.slice(0, 20);
+    for (const result of recentResults) {
+      const meta = this.journeyRowMetadata(result);
+      table.push([
+        this.truncate(result.test, 38),
+        this.formatStatus(result.status),
+        meta.failureKind !== null
+          ? chalk.red(meta.failureKind)
+          : chalk.gray("—"),
+        meta.frictionCount > 0
+          ? chalk.yellow(meta.frictionCount.toString())
+          : chalk.gray("0"),
+        meta.snapshotsDir !== null
+          ? `${meta.snapshotCount} · ${meta.snapshotsDir}`
+          : meta.snapshotCount.toString(),
+        this.formatTimestamp(result.timestamp),
+      ]);
+    }
+
+    console.log(table.toString());
+
+    if (results.length > 20) {
+      console.log(chalk.gray(`\n... and ${results.length - 20} more results`));
+    }
+
+    const summary = await resultReader.getSummary(
+      "journeys",
+      environment,
+      days,
+    );
+    console.log(chalk.bold("\nSummary:"));
+    console.log(`  Total:     ${summary.total}`);
+    console.log(`  ${chalk.green("Passed:")}   ${summary.passed}`);
+    console.log(`  ${chalk.red("Failed:")}   ${summary.failed}`);
+    console.log(`  Pass Rate: ${this.formatPassRate(summary.passRate)}`);
+    console.log();
+  }
+
+  /**
+   * Extract the journeys-specific metadata block from a JSONL row,
+   * tolerating rows written by older den versions (missing fields
+   * degrade to zero/absent — never a crash while browsing results).
+   */
+  private journeyRowMetadata(result: TestResult): JourneyRowMetadata {
+    const metadata = result.metadata ?? {};
+    const failureKind = metadata.failure_kind;
+    const frictionPoints = metadata.friction_points;
+    const snapshotCount = metadata.snapshot_count;
+    const snapshotsDir = metadata.snapshots_dir;
+
+    return {
+      failureKind: typeof failureKind === "string" ? failureKind : null,
+      frictionCount: Array.isArray(frictionPoints) ? frictionPoints.length : 0,
+      snapshotCount: typeof snapshotCount === "number" ? snapshotCount : 0,
+      snapshotsDir: typeof snapshotsDir === "string" ? snapshotsDir : null,
+    };
+  }
+
+  /**
+   * Display flaky tests
+   */
+  async displayFlakyTests(pillar: Pillar, days: number = 30): Promise<void> {
+    console.log(
+      chalk.bold(`\n⚠️  Flaky Tests: ${this.formatPillarName(pillar)}`),
+    );
+    console.log(chalk.gray("━".repeat(80)));
+
+    const flakyTests = await resultReader.getFlakyTests(pillar, days);
+
+    if (flakyTests.length === 0) {
+      console.log(chalk.green("✓ No flaky tests found!"));
+      return;
+    }
+
+    const table = new Table({
+      head: [
+        chalk.cyan("Test"),
+        chalk.cyan("Runs"),
+        chalk.cyan("Failures"),
+        chalk.cyan("Flaky Rate"),
+      ],
+      colWidths: [50, 10, 12, 15],
+      style: {
+        head: [],
+        border: ["gray"],
+      },
+      wordWrap: true,
+    });
+
+    for (const flaky of flakyTests) {
+      table.push([
+        this.truncate(flaky.test, 48),
+        flaky.runs.toString(),
+        chalk.red(flaky.failures.toString()),
+        this.formatFlakyRate(flaky.flakyRate),
+      ]);
+    }
+
+    console.log(table.toString());
+    console.log();
+  }
+
+  /**
+   * Format pillar name for display
+   */
+  private formatPillarName(pillar: Pillar): string {
+    const names: Record<Pillar, string> = {
+      synthetic: "🌐 Synthetic",
+      integration: "🔗 Integration",
+      performance: "⚡ Performance",
+      smoke: "🔥 Smoke",
+      journeys: "🧭 Journeys",
+      security: "🛡 Security",
+      suites: "🧪 Suites",
+    };
+    return names[pillar];
+  }
+
+  /**
+   * Format environment name for display
+   */
+  private formatEnvironmentName(env: Environment): string {
+    const names: Record<Environment, string> = {
+      local: "🏠 Local",
+      dev: "🔧 Dev",
+      sandbox: "🏖️  Sandbox",
+      staging: "🎭 Staging",
+      beta: "🧪 Beta",
+      prod: "🚀 Prod",
+      production: "🚀 Production",
+    };
+    return names[env];
+  }
+
+  /**
+   * Format test status with color
+   */
+  private formatStatus(status: "passed" | "failed" | "skipped"): string {
+    switch (status) {
+      case "passed":
+        return chalk.green("✓ Passed");
+      case "failed":
+        return chalk.red("✗ Failed");
+      case "skipped":
+        return chalk.yellow("○ Skipped");
+      default:
+        return status;
+    }
+  }
+
+  /**
+   * Format duration in human-readable format
+   */
+  private formatDuration(ms: number): string {
+    if (ms < 1000) {
+      return `${ms}ms`;
+    }
+    return `${(ms / 1000).toFixed(2)}s`;
+  }
+
+  /**
+   * Format timestamp in relative time
+   */
+  private formatTimestamp(timestamp: string): string {
+    const date = new Date(timestamp);
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffMins = Math.floor(diffMs / 60000);
+    const diffHours = Math.floor(diffMs / 3600000);
+    const diffDays = Math.floor(diffMs / 86400000);
+
+    if (diffMins < 1) {
+      return "just now";
+    } else if (diffMins < 60) {
+      return `${diffMins}m ago`;
+    } else if (diffHours < 24) {
+      return `${diffHours}h ago`;
+    } else if (diffDays < 7) {
+      return `${diffDays}d ago`;
+    } else {
+      return date.toLocaleDateString();
+    }
+  }
+
+  /**
+   * Format pass rate with color
+   */
+  private formatPassRate(rate: number): string {
+    const rateStr = `${rate.toFixed(1)}%`;
+
+    if (rate >= 95) {
+      return chalk.green(rateStr);
+    } else if (rate >= 80) {
+      return chalk.yellow(rateStr);
+    } else {
+      return chalk.red(rateStr);
+    }
+  }
+
+  /**
+   * Format flaky rate with color
+   */
+  private formatFlakyRate(rate: number): string {
+    const rateStr = `${rate.toFixed(1)}%`;
+
+    if (rate >= 50) {
+      return chalk.red(rateStr);
+    } else if (rate >= 20) {
+      return chalk.yellow(rateStr);
+    } else {
+      return chalk.gray(rateStr);
+    }
+  }
+
+  /**
+   * Truncate string with ellipsis
+   */
+  private truncate(str: string, maxLength: number): string {
+    if (str.length <= maxLength) {
+      return str;
+    }
+    return str.substring(0, maxLength - 3) + "...";
+  }
+}
+
+// Export singleton instance
+export const resultsViewer = new ResultsViewer();

package/src/ui/cli/secrets-preflight.ts

@@ -0,0 +1,91 @@
+/**
+ * Secrets preflight for `den up` / `restart` / `logs`.
+ *
+ * Backend-agnostic: shells out to `scripts/setup-secrets.ts --gate`, which
+ * dispatches to the configured strategy (Doppler, 1Password or env — see
+ * src/shared/secrets). A backend that is not ready only warns unless
+ * `secrets.required` is true. Synchronous so the CLI can gate before spawning work.
+ */
+import {
+  spawnSync,
+  type SpawnSyncOptionsWithStringEncoding,
+  type SpawnSyncReturns,
+} from "child_process";
+import * as path from "path";
+import { getDistRoot, getEngineRoot } from "../../shared/paths.js";
+import { engineBin } from "../../shared/engine.js";
+
+import { product } from "../../shared/product.js";
+type SpawnSyncLike = (
+  command: string,
+  args: string[],
+  options: SpawnSyncOptionsWithStringEncoding,
+) => SpawnSyncReturns<string>;
+
+export interface SecretsPreflightInvocation {
+  command: string;
+  args: string[];
+  cwd: string;
+}
+
+export interface SecretsPreflightOptions {
+  env?: NodeJS.ProcessEnv;
+  root?: string;
+  platform?: NodeJS.Platform;
+  spawnSyncImpl?: SpawnSyncLike;
+  stdio?: SpawnSyncOptionsWithStringEncoding["stdio"];
+}
+
+const truthy = (v: string | undefined) => v === "1" || v === "true";
+
+export function shouldSkipSecretsPreflight(
+  env: NodeJS.ProcessEnv = process.env,
+): boolean {
+  return truthy(env.DEN_SKIP_SECRETS);
+}
+
+/**
+ * The gate runs Den's own script (engine root) against the distribution
+ * (cwd = its root, where the org config lives).
+ */
+export function buildSecretsPreflightInvocation(
+  root = getDistRoot(),
+  platform: NodeJS.Platform = process.platform,
+  engine = getEngineRoot(),
+): SecretsPreflightInvocation {
+  return {
+    command: engineBin(platform === "win32" ? "tsx.cmd" : "tsx", engine),
+    args: [path.join(engine, "scripts", "setup-secrets.ts"), "--gate"],
+    cwd: root,
+  };
+}
+
+export function preflightSecrets(options: SecretsPreflightOptions = {}): void {
+  const env = options.env ?? process.env;
+  if (shouldSkipSecretsPreflight(env)) return;
+
+  const invocation = buildSecretsPreflightInvocation(
+    options.root,
+    options.platform,
+  );
+  const result = (options.spawnSyncImpl ?? spawnSync)(
+    invocation.command,
+    invocation.args,
+    {
+      cwd: invocation.cwd,
+      env: { ...process.env, ...env },
+      stdio: options.stdio ?? "inherit",
+      encoding: "utf-8",
+    },
+  );
+
+  if (result.status === 0) return;
+
+  const detail = result.error ? `\n${result.error.message}` : "";
+  throw new Error(
+    "Developer secrets are not configured or the secrets backend is not signed in.\n" +
+      `Run: make ${product().cli}-setup-secrets\n` +
+      `Bypass once: ${product().cli} up --skip-secrets or ${product().cli} restart --skip-secrets` +
+      detail,
+  );
+}

package/src/ui/cli/stack-command.ts

@@ -0,0 +1,117 @@
+/**
+ * `stack ls | up <name…> [--build] | down <name…> | restart <name…> | health <name…> | ps <name> | logs <name> [args]`
+ *
+ * Runs repos' Docker Compose projects with no host ports, each as its own
+ * project (`<stack>-<workspace>`), served by the edge at
+ * https://<route>.<stack>.<edge.domain>.
+ */
+import chalk from "chalk";
+import { routeUrl } from "../../shared/edge/render.js";
+import { edgeUp } from "../../shared/edge/runtime.js";
+import { projectName, startOrder } from "../../shared/stacks/render.js";
+import {
+  stackDown,
+  stackHealth,
+  stackLogs,
+  stackPs,
+  stackUp,
+} from "../../shared/stacks/runtime.js";
+import { loadStackContext, stackStatuses } from "../../shared/stacks/status.js";
+
+function serviceFlag(args: string[]): { service?: string; rest: string[] } {
+  const rest: string[] = [];
+  let service: string | undefined;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--service") service = args[++i];
+    else rest.push(args[i]);
+  }
+  return { service, rest };
+}
+
+export async function cmdStack(argv: string[]): Promise<void> {
+  const { service, rest } = serviceFlag(argv);
+  const [sub = "ls", ...args] = rest;
+  // The global -w/--workspace is parsed (and checked) before we run and
+  // arrives as DEN_WORKSPACE_OVERRIDE; loadStackContext reads it.
+  const ctx = loadStackContext();
+  const { edge, stacks } = ctx;
+  const names = args.filter((a) => !a.startsWith("-"));
+  const pick = () => {
+    if (!names.length)
+      throw new Error(
+        `Usage: stack ${sub} <name…>  (known: ${Object.keys(stacks).join(", ")})`,
+      );
+    return names;
+  };
+
+  switch (sub) {
+    case "ls":
+      for (const s of stackStatuses(ctx)) {
+        console.log(
+          chalk.bold(`${s.name}`) +
+            chalk.gray(
+              `  ${s.repo}${s.dir ? `/${s.dir}` : ""}  project ${s.project}`,
+            ),
+        );
+        for (const route of s.routes)
+          console.log(`  ${route.url}  → ${route.target}`);
+        if (s.uses.length)
+          console.log(chalk.gray(`  uses ${s.uses.join(", ")}`));
+      }
+      return;
+    case "up": {
+      // Re-render the edge so its cert covers every stack, then start the stacks.
+      await edgeUp(edge);
+      for (const n of startOrder(pick(), stacks)) {
+        console.log(chalk.cyan(`\n▶ ${n} (${projectName(n, ctx.workspace)})`));
+        stackUp(ctx, stacks[n], { build: args.includes("--build") });
+        for (const route of Object.keys(stacks[n].routes))
+          console.log(chalk.green(`  ✓ ${routeUrl(`${route}.${n}`, edge)}`));
+      }
+      return;
+    }
+    case "restart":
+      await edgeUp(edge);
+      for (const n of pick()) {
+        console.log(chalk.cyan(`↻ ${n}`));
+        stackDown(ctx, stacks[n]);
+        stackUp(ctx, stacks[n], { build: args.includes("--build") });
+      }
+      return;
+    case "health": {
+      let ok = true;
+      for (const n of pick()) {
+        const h = stackHealth(ctx, stacks[n], service);
+        ok &&= h.ok;
+        console.log(
+          `${h.ok ? chalk.green("✓") : chalk.red("✗")} ${n}  ${h.detail}`,
+        );
+      }
+      process.exitCode = ok ? 0 : 1;
+      return;
+    }
+    case "down":
+      for (const n of startOrder(pick(), stacks)
+        .reverse()
+        .filter((n) => names.includes(n))) {
+        console.log(chalk.cyan(`▼ ${n}`));
+        stackDown(ctx, stacks[n]);
+      }
+      return;
+    case "ps":
+      for (const n of pick())
+        console.log(chalk.bold(n) + "\n" + stackPs(ctx, stacks[n]));
+      return;
+    case "logs":
+      process.exitCode = stackLogs(
+        ctx,
+        stacks[pick()[0]],
+        args.filter((a) => a !== names[0]),
+      );
+      return;
+    default:
+      throw new Error(
+        `Unknown stack command "${sub}". Use: ls | up | down | restart | health | ps | logs`,
+      );
+  }
+}