@monster-orange/den 0.0.0 → 0.2.0

package/src/pillars/smoke/staging.ts

@@ -0,0 +1,49 @@
+import * as fs from "fs";
+import * as path from "path";
+
+export interface StageSmokeTreeResult {
+  copiedFiles: number;
+  matchedTestFiles: number;
+}
+
+function testMatchToRegex(testMatch: string): RegExp {
+  const matchExt = testMatch.replace(/^\*\*\/\*\./, "").replace(/\./g, "\\.");
+  return new RegExp(`\\.${matchExt}$`);
+}
+
+export function stageSmokeTree(
+  sourceDir: string,
+  destinationDir: string,
+  testMatch: string,
+): StageSmokeTreeResult {
+  const testRegex = testMatchToRegex(testMatch);
+  let copiedFiles = 0;
+  let matchedTestFiles = 0;
+
+  function copyRecursive(src: string, dst: string): void {
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+      const sourcePath = path.join(src, entry.name);
+      const destinationPath = path.join(dst, entry.name);
+
+      if (entry.isDirectory()) {
+        fs.mkdirSync(destinationPath, { recursive: true });
+        copyRecursive(sourcePath, destinationPath);
+        continue;
+      }
+
+      fs.copyFileSync(sourcePath, destinationPath);
+      copiedFiles += 1;
+      if (testRegex.test(entry.name)) {
+        matchedTestFiles += 1;
+      }
+    }
+  }
+
+  fs.mkdirSync(destinationDir, { recursive: true });
+  copyRecursive(sourceDir, destinationDir);
+
+  return {
+    copiedFiles,
+    matchedTestFiles,
+  };
+}

package/src/pillars/suites/run.ts

@@ -0,0 +1,147 @@
+/**
+ * `den suites`: run the test suites each repo declares in its manifest.
+ *
+ *   tsx src/pillars/suites/run.ts --env local [--suite repo/name ...]
+ *
+ * A suite is a shell command run from the repo's checkout (or `cwd` under
+ * it). It gets DEN_ENV and BASE_URL (the repo entrypoint's URL for the env).
+ * Local only unless the suite lists other environments; prod never.
+ */
+
+import { spawn } from "child_process";
+import * as path from "path";
+import { openUrlFor } from "../../shared/manifest/service-links.js";
+import { listServicesWithManifests } from "../../shared/manifest/workspace-manifests.js";
+import type { Environment, TestSuiteConfig } from "../../shared/types/index.js";
+
+import { product } from "../../shared/product.js";
+export interface PlannedSuite {
+  id: string;
+  repo: string;
+  name: string;
+  label: string;
+  cmd: string;
+  cwd: string;
+  baseUrl: string | null;
+}
+
+export function suiteRefusal(
+  suite: TestSuiteConfig,
+  env: Environment,
+): string | null {
+  if (env === "prod" || env === "production")
+    return `${product().title} never runs suites against production`;
+  const allowed = suite.environments ?? ["local"];
+  return allowed.includes(env)
+    ? null
+    : `declared for ${allowed.join(", ")} only`;
+}
+
+/** Every repo suite runnable on env; `only` narrows to repo/name or repo. */
+export function planSuites(
+  services: ReturnType<typeof listServicesWithManifests>,
+  env: Environment,
+  only: string[] = [],
+): { run: PlannedSuite[]; skipped: Array<{ id: string; why: string }> } {
+  const run: PlannedSuite[] = [];
+  const skipped: Array<{ id: string; why: string }> = [];
+  const seen = new Set<string>();
+  for (const s of services) {
+    if (seen.has(s.repo)) continue;
+    seen.add(s.repo);
+    const entry = s.manifest.entrypoint
+      ? s.manifest.services?.[s.manifest.entrypoint]
+      : undefined;
+    for (const [name, suite] of Object.entries(s.manifest.tests ?? {})) {
+      const id = `${s.repo}/${name}`;
+      if (only.length && !only.includes(id) && !only.includes(s.repo)) continue;
+      const why = suiteRefusal(suite, env);
+      if (why) {
+        skipped.push({ id, why });
+        continue;
+      }
+      const cwd = path.resolve(s.repoPath, suite.cwd ?? ".");
+      const root = path.resolve(s.repoPath);
+      if (cwd !== root && !cwd.startsWith(root + path.sep)) {
+        skipped.push({ id, why: "cwd leaves the checkout" });
+        continue;
+      }
+      run.push({
+        id,
+        repo: s.repo,
+        name,
+        label: suite.label ?? name,
+        cmd: suite.cmd,
+        cwd,
+        baseUrl: openUrlFor(entry, env),
+      });
+    }
+  }
+  return { run, skipped };
+}
+
+function runSuite(s: PlannedSuite, env: Environment): Promise<number> {
+  return new Promise((resolve) => {
+    const child = spawn("sh", ["-c", s.cmd], {
+      cwd: s.cwd,
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        DEN_ENV: env,
+        ...(s.baseUrl ? { BASE_URL: s.baseUrl } : {}),
+      },
+    });
+    child.on("error", () => resolve(127));
+    child.on("close", (code) => resolve(code ?? 1));
+  });
+}
+
+export async function main(argv = process.argv.slice(2)): Promise<number> {
+  const i = argv.indexOf("--env");
+  const env = (
+    i >= 0 && argv[i + 1]
+      ? argv[i + 1]
+      : (argv.find((a) => a.startsWith("--env="))?.slice(6) ?? "local")
+  ) as Environment;
+  const only: string[] = [];
+  argv.forEach((a, i) => {
+    if (a === "--suite" && argv[i + 1]) only.push(argv[i + 1]);
+    else if (a.startsWith("--suite=")) only.push(a.slice(8));
+  });
+
+  const { run, skipped } = planSuites(listServicesWithManifests(), env, only);
+  for (const s of skipped) console.log(`– ${s.id}: skipped (${s.why})`);
+  if (run.length === 0) {
+    console.log(
+      `No repo suite to run on ${env}. Declare them under tests: in ${product().manifestYml}.`,
+    );
+    return skipped.length && only.length ? 2 : 0;
+  }
+  const results: Array<{ id: string; code: number; ms: number }> = [];
+  for (const s of run) {
+    console.log(`\n▶ ${s.id}: ${s.cmd}  (in ${s.cwd})`);
+    const t0 = Date.now();
+    const code = await runSuite(s, env);
+    results.push({ id: s.id, code, ms: Date.now() - t0 });
+    console.log(`${code === 0 ? "✓" : "✗"} ${s.id} exited ${code}`);
+  }
+  console.log("\nSuites:");
+  for (const r of results)
+    console.log(
+      `  ${r.code === 0 ? "✓" : "✗"} ${r.id}  ${(r.ms / 1000).toFixed(1)}s`,
+    );
+  return results.some((r) => r.code !== 0) ? 1 : 0;
+}
+
+const isDirectRun =
+  process.argv[1] &&
+  path.resolve(process.argv[1]).includes("pillars/suites/run");
+if (isDirectRun) {
+  main().then(
+    (code) => process.exit(code),
+    (err) => {
+      console.error(`✗ ${(err as Error).message}`);
+      process.exit(2);
+    },
+  );
+}

package/src/scripts/configure-aws-profiles.ts

@@ -0,0 +1,114 @@
+/**
+ * configure-aws-profiles
+ *
+ * Interactively maps den environments to AWS CLI profiles.
+ * Writes the selection to config/local/aws-profiles.json (gitignored).
+ *
+ * Usage:
+ *   make aws-configure
+ *   npx tsx src/scripts/configure-aws-profiles.ts
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import { execSync } from "child_process";
+import inquirer from "inquirer";
+import type { Environment } from "../shared/types/index.js";
+import { getDistRoot } from "../shared/paths.js";
+
+import { product } from "../shared/product.js";
+// Den-root anchored: WRITES config/local/aws-profiles.json, and the reader
+// (shared/environment/aws-profiles.ts) already anchors at getDistRoot().
+const ROOT = getDistRoot();
+const CONFIG_DIR = path.join(ROOT, "config", "local");
+const PROFILES_FILE = path.join(CONFIG_DIR, "aws-profiles.json");
+
+/** Environments that may need AWS credentials (local uses Docker). */
+const AWS_ENVS: Environment[] = ["dev", "sandbox", "staging", "production"];
+
+function listAwsProfiles(): string[] {
+  try {
+    const out = execSync("aws configure list-profiles", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return out.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+async function main() {
+  console.log(`\n  ${product().cli} · Configure AWS Profiles\n`);
+  console.log("  Maps each environment to an AWS CLI profile used for");
+  console.log("  CloudWatch log streaming, health checks, and re-auth.\n");
+
+  const profiles = listAwsProfiles();
+
+  if (!profiles.length) {
+    console.log(
+      "  ⚠  No AWS profiles found. Run 'aws configure' or set up AWS SSO first.\n",
+    );
+    console.log(
+      "  You can still save an empty config and re-run later with: make aws-configure\n",
+    );
+  } else {
+    console.log(
+      `  Found ${profiles.length} profile(s): ${profiles.join(", ")}\n`,
+    );
+  }
+
+  // Load existing config
+  let existing: Partial<Record<Environment, string>> = {};
+  if (fs.existsSync(PROFILES_FILE)) {
+    try {
+      existing = JSON.parse(fs.readFileSync(PROFILES_FILE, "utf-8"));
+      console.log("  Current config:");
+      for (const [env, profile] of Object.entries(existing)) {
+        console.log(`    ${env.padEnd(12)} → ${profile}`);
+      }
+      console.log("");
+    } catch {
+      /* start fresh */
+    }
+  }
+
+  const choices = [
+    { name: "(none — skip this environment)", value: "" },
+    ...profiles.map((p) => ({ name: p, value: p })),
+  ];
+
+  const questions = AWS_ENVS.map((env) => ({
+    type: "list" as const,
+    name: env,
+    message: `AWS profile for ${env}:`,
+    choices,
+    default: existing[env] ?? "",
+  }));
+
+  const answers = await inquirer.prompt<Record<Environment, string>>(questions);
+
+  // Build result, dropping empty selections
+  const result: Partial<Record<Environment, string>> = {};
+  for (const env of AWS_ENVS) {
+    if (answers[env]) result[env] = answers[env];
+  }
+
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(PROFILES_FILE, JSON.stringify(result, null, 2) + "\n");
+
+  console.log("\n  Saved to config/local/aws-profiles.json");
+  if (Object.keys(result).length) {
+    for (const [env, profile] of Object.entries(result)) {
+      console.log(`    ${env.padEnd(12)} → ${profile}`);
+    }
+  } else {
+    console.log("    (no profiles configured)");
+  }
+  console.log("\n  Re-run any time with: make aws-configure\n");
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/scripts/register-repos.ts

@@ -0,0 +1,307 @@
+/**
+ * register-repos — where test discovery gets its repos.
+ *
+ * With Local Dev enabled (the default), smoke/performance/synthetics
+ * discovery follows the ACTIVE WORKSPACE (see pillars/smoke/discover.ts):
+ * the same repos you develop against are the repos tests run against, and a
+ * fresh clone seeds every standard system repo managed out of the box.
+ * In that mode there is nothing to register — this script just reports the
+ * effective test sources.
+ *
+ * The legacy sibling-directory scan (interactive checkbox → writes
+ * config/local/registered-repos.json, gitignored) remains for hosted /
+ * no-local setups, where the workspace doesn't exist:
+ *
+ *   make register-repos                # report (or legacy scan when local off)
+ *   make register-repos args=--legacy  # force the interactive sibling scan
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import inquirer from "inquirer";
+import { parse as parseYaml } from "yaml";
+import { getDistRoot } from "../shared/paths.js";
+import { getReposRoot, isLocalEnabled } from "../shared/den-config.js";
+import { getActiveWorkspace } from "../shared/environment-manager/workspaces.js";
+import {
+  defaultWorkspaceRepos,
+  topUpDefaultWorkspace,
+} from "../shared/environment-manager/default-workspace.js";
+
+import { product } from "../shared/product.js";
+// Anchored to the den root, NOT process.cwd() — this script WRITES
+// config/local/* and a cwd-derived root once put den files in another repo.
+const ROOT = getDistRoot();
+const CONFIG_DIR = path.join(ROOT, "config", "local");
+const REGISTERED_FILE = path.join(CONFIG_DIR, "registered-repos.json");
+const MANIFEST_NAMES = [
+  `${product().manifestYml}`,
+  `${product().manifestJson}`,
+] as const;
+
+// ── Mode selection (pure — unit tested) ───────────────────────────────────────
+
+export type RegistrationPlan =
+  | {
+      mode: "workspace";
+      workspaceName: string;
+      repos: { name: string; managed: boolean }[];
+    }
+  | { mode: "defaults"; repos: string[] }
+  | { mode: "legacy" };
+
+/**
+ * Decide what running register-repos should do.
+ *
+ * Workspace-driven discovery makes registration a no-op, so the only reasons
+ * to run the legacy sibling scan are an explicit --legacy or Local Dev being
+ * disabled (hosted setups, where no workspace exists to follow).
+ */
+export function planRegistration(opts: {
+  localEnabled: boolean;
+  legacyRequested: boolean;
+  workspace: {
+    name: string;
+    services: Record<string, { mode?: string }>;
+  } | null;
+  defaultRepos: string[];
+}): RegistrationPlan {
+  if (opts.legacyRequested || !opts.localEnabled) return { mode: "legacy" };
+  // An EMPTY workspace (declined seed, or user-emptied) reports like no
+  // workspace: the defaults message says what the first den command will
+  // do, where a zero-row workspace table says nothing actionable.
+  if (opts.workspace && Object.keys(opts.workspace.services).length > 0) {
+    return {
+      mode: "workspace",
+      workspaceName: opts.workspace.name,
+      repos: Object.entries(opts.workspace.services).map(([name, svc]) => ({
+        name,
+        // Missing mode means dev-managed everywhere else in the system
+        // (normalizeMode in workspaces.ts) — mirror that, never invert it.
+        managed: svc.mode === "managed",
+      })),
+    };
+  }
+  return { mode: "defaults", repos: opts.defaultRepos };
+}
+
+// ── Legacy sibling scan (hosted / no-local setups) ────────────────────────────
+
+interface Candidate {
+  name: string;
+  repoPath: string;
+  description: string;
+}
+
+function scanForManifests(searchDir: string): Candidate[] {
+  const candidates: Candidate[] = [];
+
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(searchDir, { withFileTypes: true });
+  } catch {
+    console.warn(`  Could not read directory: ${searchDir}`);
+    return [];
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+
+    const repoPath = path.join(searchDir, entry.name);
+
+    // Skip den itself
+    try {
+      if (fs.realpathSync(repoPath) === fs.realpathSync(ROOT)) continue;
+    } catch {
+      continue;
+    }
+
+    const manifestPath = MANIFEST_NAMES.map((n) => path.join(repoPath, n)).find(
+      (p) => fs.existsSync(p),
+    );
+    if (!manifestPath) continue;
+
+    try {
+      const raw = fs.readFileSync(manifestPath, "utf-8");
+      const manifest = (
+        manifestPath.endsWith(".yml") ? parseYaml(raw) : JSON.parse(raw)
+      ) as {
+        name?: string;
+        smoke?: Record<string, unknown>;
+        services?: Record<string, unknown>;
+        synthetics?: unknown;
+        journeys?: unknown;
+        security?: Record<string, unknown>;
+      };
+
+      const capabilities: string[] = [];
+      if (manifest.smoke)
+        capabilities.push(`smoke(${Object.keys(manifest.smoke).join(",")})`);
+      if (manifest.services)
+        capabilities.push(
+          `services(${Object.keys(manifest.services).join(",")})`,
+        );
+      if (manifest.synthetics) capabilities.push("synthetics");
+      if (manifest.journeys) capabilities.push("journeys");
+      if (manifest.security)
+        capabilities.push(
+          `security(${Object.keys(manifest.security).join(",")})`,
+        );
+
+      candidates.push({
+        name: manifest.name ?? entry.name,
+        repoPath,
+        description: capabilities.length
+          ? capabilities.join("  ")
+          : "(no capabilities)",
+      });
+    } catch {
+      // Malformed manifest — still offer it
+      candidates.push({
+        name: entry.name,
+        repoPath,
+        description: "(unreadable manifest)",
+      });
+    }
+  }
+
+  return candidates;
+}
+
+async function legacyScanAndSelect(): Promise<void> {
+  console.log(`\n  ${product().cli} · Register Repos (legacy sibling scan)\n`);
+
+  // Load current registrations
+  let existing: string[] = [];
+  if (fs.existsSync(REGISTERED_FILE)) {
+    try {
+      existing = JSON.parse(
+        fs.readFileSync(REGISTERED_FILE, "utf-8"),
+      ) as string[];
+      console.log(
+        `  Current: ${existing.length} repo(s) registered for testing\n`,
+      );
+    } catch {
+      /* corrupt file — start fresh */
+    }
+  }
+
+  // Scan the configured repos root (defaults to the den root's parent)
+  const parentDir = getReposRoot();
+  console.log(
+    `  Scanning ${parentDir} for ${product().manifestYml} / ${product().manifestJson} ...\n`,
+  );
+  const candidates = scanForManifests(parentDir);
+
+  if (!candidates.length) {
+    console.log(
+      `  No sibling repos with ${product().manifestYml} or ${product().manifestJson} found.`,
+    );
+    console.log(
+      "  Add custom paths manually to config/local/registered-repos.json\n",
+    );
+    return;
+  }
+
+  // Prompt
+  const { selected } = await inquirer.prompt<{ selected: string[] }>([
+    {
+      type: "checkbox",
+      name: "selected",
+      message: `Select repos to register with ${product().cli} (space to toggle, enter to confirm):`,
+      choices: candidates.map((c) => ({
+        name: `${c.name.padEnd(20)} ${c.repoPath}   ${c.description}`,
+        value: c.repoPath,
+        checked: existing.includes(c.repoPath),
+      })),
+      pageSize: 15,
+    },
+  ]);
+
+  // Persist
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(REGISTERED_FILE, JSON.stringify(selected, null, 2) + "\n");
+
+  console.log(
+    `\n  Registered ${selected.length} repo(s) → config/local/registered-repos.json`,
+  );
+  console.log("  Run `make register-repos` again at any time to update.\n");
+}
+
+// ── Entry ─────────────────────────────────────────────────────────────────────
+
+async function main(): Promise<void> {
+  const legacyRequested = process.argv.includes("--legacy");
+  const localEnabled = isLocalEnabled();
+
+  // Converge first: a workspace seeded before a repo joined the blueprint
+  // (tasks-api, say) is missing a first-class system repo — add it so the
+  // report below shows the true standard set, not a stale snapshot. Skipped
+  // on the legacy / no-local paths, which never read the workspace and must
+  // not write it either.
+  const toppedUp =
+    legacyRequested || !localEnabled ? [] : topUpDefaultWorkspace();
+  if (toppedUp.length > 0) {
+    console.log(
+      `\n  Added standard repo(s) to the default workspace: ${toppedUp.join(", ")} (managed)`,
+    );
+  }
+
+  const active = getActiveWorkspace();
+  const plan = planRegistration({
+    localEnabled,
+    legacyRequested,
+    workspace: active
+      ? { name: active.name, services: active.config.services }
+      : null,
+    defaultRepos: defaultWorkspaceRepos(),
+  });
+
+  if (plan.mode === "workspace") {
+    console.log(`\n  ${product().cli} · Test repo sources\n`);
+    console.log(
+      `  Local Dev is enabled — test discovery follows your active workspace` +
+        ` ("${plan.workspaceName}"):\n  the repos you develop against are the` +
+        ` repos tests run against. Nothing to register.\n`,
+    );
+    for (const r of plan.repos) {
+      console.log(
+        `    ${r.name.padEnd(20)} ${r.managed ? "managed" : "dev-managed"}`,
+      );
+    }
+    console.log(
+      "\n  Flip any repo between managed and dev-managed in the web UX" +
+        `\n  (or \`${product().cli} use-local <repo>\`); tests pick the change up automatically.` +
+        "\n  Sibling-path registration for hosted setups: make register-repos args=--legacy\n",
+    );
+    return;
+  }
+
+  if (plan.mode === "defaults") {
+    console.log(`\n  ${product().cli} · Test repo sources\n`);
+    console.log(
+      "  Local Dev is enabled but no workspace exists yet. Your first" +
+        ` \`${product().cli}\` command\n  seeds the default workspace with every standard` +
+        ` system repo, all managed\n  out of the box (${plan.repos.length} repos):\n`,
+    );
+    console.log(`    ${plan.repos.join(", ")}\n`);
+    console.log(
+      "  Test discovery follows that workspace automatically — nothing to register.\n",
+    );
+    return;
+  }
+
+  await legacyScanAndSelect();
+}
+
+// Direct-run guard: jest imports this module for planRegistration — only run
+// the CLI when executed as a script (jest's argv[1] is the jest binary).
+const isDirectRun = Boolean(
+  process.argv[1] && /register-repos\.(ts|js)$/.test(process.argv[1]),
+);
+if (isDirectRun) {
+  main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}