@rehearsal-db/core 0.1.0-beta.5 → 0.1.0-beta.7

package/scripts/operations/rehearsal/rehearsal_cli.mjs

@@ -56,6 +56,10 @@ import {
   suggestPolicyExceptionColumns,
 } from "../../lib/rehearsal/policy_review.mjs";
 import { collectRehearsalSupportReport } from "../../lib/rehearsal/support_report.mjs";
+import {
+  applyRehearsalCleanup,
+  planRehearsalCleanup,
+} from "../../lib/rehearsal/cleanup.mjs";
 
 const packageRoot = fileURLToPath(new URL("../../..", import.meta.url));
 const projectRoot = process.cwd();
@@ -80,6 +84,10 @@ const parseArguments = (arguments_) => {
     recordsPath: undefined,
     ledgerPath: undefined,
     assetsPath: undefined,
+    target: undefined,
+    includeRuntime: false,
+    includeImages: false,
+    cleanupConfirmation: undefined,
   };
   const positionals = [];
   for (const argument of arguments_) {
@@ -94,12 +102,20 @@ const parseArguments = (arguments_) => {
       flags.configPath = argument.slice("--config=".length);
     } else if (argument.startsWith("--confirm-candidates=")) {
       flags.confirmation = argument.slice("--confirm-candidates=".length);
+    } else if (argument.startsWith("--confirm-cleanup=")) {
+      flags.cleanupConfirmation = argument.slice("--confirm-cleanup=".length);
     } else if (argument.startsWith("--records=")) {
       flags.recordsPath = argument.slice("--records=".length);
     } else if (argument.startsWith("--ledger=")) {
       flags.ledgerPath = argument.slice("--ledger=".length);
     } else if (argument.startsWith("--assets=")) {
       flags.assetsPath = argument.slice("--assets=".length);
+    } else if (argument.startsWith("--target=")) {
+      flags.target = argument.slice("--target=".length);
+    } else if (argument === "--include-runtime") {
+      flags.includeRuntime = true;
+    } else if (argument === "--include-images") {
+      flags.includeImages = true;
     } else if (argument.startsWith("--")) {
       throw new Error(`Unknown Rehearsal option: ${argument}.`);
     } else positionals.push(argument);
@@ -128,7 +144,7 @@ const renderPlan = (plan, verbosity) => {
     "Environment",
     `  ✓ ${plan.environment.kind}`,
     `  ✓ Hosted access ${plan.environment.hostedAccess}`,
-    `  ✓ Application/provider-data egress ${plan.environment.outboundNetwork}`,
+    `  ✓ Hosted target configuration ${plan.environment.outboundNetwork}`,
     ...(plan.environment.authenticationProviders.length
       ? [
           `  ✓ External identity providers ${plan.environment.authenticationProviders.join(", ")}`,
@@ -274,7 +290,12 @@ const formatDuration = (durationMs) =>
     ? `${Math.round(durationMs)}ms`
     : `${(durationMs / 1_000).toFixed(1)}s`;
 
-const promptForChoice = async ({ message, options, flags = {} }) => {
+const promptForChoice = async ({
+  message,
+  options,
+  flags = {},
+  optionsAlreadyShown = false,
+}) => {
   if (useStyledPrompts(flags)) {
     const selected = await prompts.select({
       message,
@@ -289,6 +310,18 @@ const promptForChoice = async ({ message, options, flags = {} }) => {
       ? options.find((option) => option.command === "exit")
       : selected;
   }
+  if (!optionsAlreadyShown) {
+    console.log(
+      [
+        "",
+        ...options.map(
+          (option, index) =>
+            `  ${index === 0 ? "›" : " "} ${index + 1}. ${option.label}${option.hint ? ` — ${option.hint}` : ""}`,
+        ),
+        "",
+      ].join("\n"),
+    );
+  }
   const prompt = createInterface({
     input: process.stdin,
     output: process.stdout,
@@ -502,6 +535,7 @@ const inspectGuidedProject = async (planOptions) => {
       detected,
       node,
       config: "missing",
+      target: detected.hasSupabaseConfig ? "supabase" : "postgresql",
       baseline: false,
       runtime: false,
     };
@@ -514,6 +548,7 @@ const inspectGuidedProject = async (planOptions) => {
       detected,
       node,
       config: "invalid",
+      target: undefined,
       configPath,
       configError: redactDiagnosticValue(String(error?.message ?? error)),
       baseline: false,
@@ -544,6 +579,7 @@ const inspectGuidedProject = async (planOptions) => {
     detected,
     node,
     config: "valid",
+    target: loaded.config.runtime.target,
     configPath,
     baseline: Boolean(migrationSummary),
     policy,
@@ -811,6 +847,13 @@ const runGuidedHome = async ({ flags, planOptions }) => {
       command: "manage-runtime",
     });
   }
+  if (state.node.supported && state.config === "valid") {
+    options.push({
+      label: "Clean up disk space",
+      hint: "Preview old baselines, the runtime, and unused images",
+      command: "cleanup-guide",
+    });
+  }
   if (lastGuidedDetails) {
     options.push({
       label: "Show details from the last action",
@@ -829,8 +872,16 @@ const runGuidedHome = async ({ flags, planOptions }) => {
 
   const statusLines = [
     `${marker(state.node.supported)} Node.js ${state.node.version}${state.node.supported ? "" : " (Node.js 24 required)"}`,
-    `${marker(state.detected.hasSupabaseConfig)} Supabase project detected`,
-    `${marker(state.detected.hasMigrations)} Migration history detected`,
+    `${marker(
+      state.target === "supabase"
+        ? state.detected.hasSupabaseConfig
+        : state.detected.hasPostgresqlMigrations,
+    )} ${state.target === "supabase" ? "Supabase" : "PostgreSQL"} project detected`,
+    `${marker(
+      state.target === "supabase"
+        ? state.detected.hasMigrations
+        : state.detected.hasPostgresqlMigrations,
+    )} Migration history detected`,
     `${marker(state.config === "valid")} Rehearsal configuration${state.config === "invalid" ? " needs attention" : ""}`,
     ...(state.config === "valid"
       ? [
@@ -882,6 +933,7 @@ const runGuidedHome = async ({ flags, planOptions }) => {
     message: "What would you like to do?",
     options,
     flags,
+    optionsAlreadyShown: !useStyledPrompts(flags),
   });
   if (selected.command === "exit") {
     return null;
@@ -950,13 +1002,67 @@ const runGuidedHome = async ({ flags, planOptions }) => {
     }
     return runtimeAction.command;
   }
+  if (selected.command === "cleanup-guide") {
+    const cleanupScope = await promptForChoice({
+      message: "What may Rehearsal include in the cleanup preview?",
+      flags,
+      options: [
+        {
+          label: "Old baselines only",
+          hint: "Keep the configured number of recent generations",
+          command: "baselines",
+        },
+        {
+          label: "Old baselines and this project's runtime",
+          hint: "Also remove the disposable database and its volumes",
+          command: "runtime",
+        },
+        {
+          label: "Old baselines and older unused Supabase images",
+          hint: "Images may be shared and can be downloaded again",
+          command: "images",
+        },
+        {
+          label: "Everything above",
+          command: "all",
+        },
+        { label: "Back", command: "exit" },
+      ],
+    });
+    if (!cleanupScope || cleanupScope.command === "exit") return "refresh";
+    flags.includeRuntime = ["runtime", "all"].includes(cleanupScope.command);
+    flags.includeImages = ["images", "all"].includes(cleanupScope.command);
+    flags.cleanupPlan = await planRehearsalCleanup({
+      ...planOptions,
+      includeRuntime: flags.includeRuntime,
+      includeImages: flags.includeImages,
+    });
+    console.log(
+      `\n${renderCleanup({ mode: "preview", plan: flags.cleanupPlan })}`,
+    );
+    const selectedCount =
+      flags.cleanupPlan.baselines.removed.length +
+      (flags.cleanupPlan.runtime.included && flags.cleanupPlan.runtime.detected
+        ? 1
+        : 0) +
+      flags.cleanupPlan.images.candidates.length;
+    if (selectedCount === 0) return "refresh";
+    const accepted = await promptForConfirmation(
+      "Remove exactly the resources shown above?",
+      flags,
+    );
+    if (!accepted) return "refresh";
+    flags.write = true;
+    flags.cleanupConfirmation = flags.cleanupPlan.digest;
+    return "cleanup";
+  }
   if (["baseline-guide", "baseline-prepare"].includes(selected.command)) {
     console.log(
       [
         "",
         terminalStyle(flags, "1", "CREATE A SAFE BASELINE"),
         "Rehearsal only reads the local files you name here.",
-        "It does not extract data or contact a hosted Supabase project.",
+        "It does not extract data or contact a hosted database.",
         "",
       ].join("\n"),
     );
@@ -968,9 +1074,13 @@ const runGuidedHome = async ({ flags, planOptions }) => {
       discovered.ledgers.length
         ? `Migration ledgers: ${discovered.ledgers.join(", ")}`
         : "Migration ledgers: none detected",
-      discovered.assetManifests.length
-        ? `Storage manifests: ${discovered.assetManifests.join(", ")}`
-        : "Storage manifests: none detected",
+      ...(state.target === "supabase"
+        ? [
+            discovered.assetManifests.length
+              ? `Storage manifests: ${discovered.assetManifests.join(", ")}`
+              : "Storage manifests: none detected",
+          ]
+        : []),
       "Only paths and file structure were inspected; row values stay hidden.",
     ];
     if (useStyledPrompts(flags)) {
@@ -1017,12 +1127,15 @@ const runGuidedHome = async ({ flags, planOptions }) => {
         flags.write = true;
         return "baseline prepare";
       }
-      flags.assetsPath = await promptForDiscoveredPath({
-        message: "Storage assets",
-        candidates: discovered.assetManifests,
-        optional: true,
-        flags,
-      });
+      flags.assetsPath =
+        state.target === "supabase"
+          ? await promptForDiscoveredPath({
+              message: "Storage assets",
+              candidates: discovered.assetManifests,
+              optional: true,
+              flags,
+            })
+          : undefined;
       const inspection = await inspectBaselineInputFiles({
         ...planOptions,
         recordsPath: flags.recordsPath,
@@ -1052,7 +1165,26 @@ const runGuidedHome = async ({ flags, planOptions }) => {
   }
   if (selected.command !== "setup-write") return selected.command;
 
-  const setupPlan = await planRehearsalSetup({ projectRoot });
+  const targetChoice = await promptForChoice({
+    message: "Which database should Rehearsal use?",
+    flags,
+    options:
+      state.target === "supabase"
+        ? [
+            { label: "Supabase", command: "supabase" },
+            { label: "PostgreSQL", command: "postgresql" },
+          ]
+        : [
+            { label: "PostgreSQL", command: "postgresql" },
+            { label: "Supabase", command: "supabase" },
+          ],
+  });
+  if (!targetChoice) return "refresh";
+  flags.target = targetChoice.command;
+  const setupPlan = await planRehearsalSetup({
+    projectRoot,
+    target: flags.target,
+  });
   const preview = {
     ...summarizeRehearsalSetup(setupPlan, { mode: "preview" }),
     nextAction:
@@ -1215,6 +1347,14 @@ const runManager = ({ action, flags }) => {
     const inferred = normalizeRehearsalError(
       new Error(completeOutput || `Rehearsal ${action} failed.`),
     );
+    const category =
+      action === "migrate" ||
+      (action === "run" &&
+        /migrateRuntime|candidate migration|migration up/iu.test(
+          completeOutput,
+        ))
+        ? "migration_candidate_failure"
+        : inferred.category;
     const conciseOutput = completeOutput
       .replaceAll(String.fromCodePoint(27), "")
       .split("\n")
@@ -1224,7 +1364,7 @@ const runManager = ({ action, flags }) => {
       .join("\n")
       .slice(-2_000);
     throw new RehearsalError({
-      category: inferred.category,
+      category,
       code: `MANAGER_${action.toUpperCase()}_FAILED`,
       message: `The local Rehearsal ${action} operation did not complete.`,
       expected: "the isolated runtime operation to finish and verify",
@@ -1382,7 +1522,12 @@ const renderInit = (result) =>
   ].join("\n");
 
 const runSetup = async ({ flags, planOptions }) => {
-  const plan = flags.setupPlan ?? (await planRehearsalSetup({ projectRoot }));
+  const plan =
+    flags.setupPlan ??
+    (await planRehearsalSetup({
+      projectRoot,
+      target: flags.target ?? "supabase",
+    }));
   if (flags.write) await applyRehearsalSetup(plan);
   const result = summarizeRehearsalSetup(plan, {
     mode: flags.write ? "written" : "preview",
@@ -1454,9 +1599,12 @@ const renderSetup = (result) => {
   return [
     `REHEARSAL SETUP — ${result.mode.toUpperCase()}`,
     `Project: ${result.project}`,
+    `Database: ${result.target === "postgresql" ? "PostgreSQL" : "Supabase"}`,
     `Runtime ID: ${result.projectId}`,
     `Application: ${result.applicationUrl}`,
-    `Ports: API ${result.ports.api}, database ${result.ports.database}, Studio ${result.ports.studio}`,
+    result.target === "postgresql"
+      ? `Port: database ${result.ports.database}`
+      : `Ports: API ${result.ports.api}, database ${result.ports.database}, Studio ${result.ports.studio}`,
     "",
     "Files",
     ...result.files.map(
@@ -1567,11 +1715,117 @@ const renderSupportReport = (report) => {
   ].join("\n");
 };
 
+const formatBytes = (bytes) => {
+  if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
+  const units = ["B", "KiB", "MiB", "GiB", "TiB"];
+  const unit = Math.min(
+    Math.floor(Math.log(bytes) / Math.log(1024)),
+    units.length - 1,
+  );
+  const value = bytes / 1024 ** unit;
+  return `${value >= 10 || unit === 0 ? value.toFixed(0) : value.toFixed(1)} ${units[unit]}`;
+};
+
+const renderCleanup = (result) => {
+  const plan = result.plan;
+  const imageBytes = plan.images.candidates.reduce(
+    (total, image) => total + image.bytes,
+    0,
+  );
+  const dockerImages = plan.docker.resources.find(
+    (resource) => resource.Type === "Images",
+  );
+  const selectedCount =
+    plan.baselines.removed.length +
+    (plan.runtime.included && plan.runtime.detected ? 1 : 0) +
+    plan.images.candidates.length;
+  return [
+    `REHEARSAL CLEANUP — ${result.mode.toUpperCase()}`,
+    `Project: ${plan.project}`,
+    ...(dockerImages
+      ? [
+          `Docker images: ${dockerImages.Size}; ${dockerImages.Reclaimable} reclaimable across Docker`,
+        ]
+      : ["Docker usage: unavailable"]),
+    ...(plan.docker.disk
+      ? [
+          `Container disk: ${formatBytes(plan.docker.disk.usedBytes)} used of ${formatBytes(plan.docker.disk.totalBytes)}; ${formatBytes(plan.docker.disk.availableBytes)} free (${plan.docker.disk.usedPercent}% used)`,
+        ]
+      : []),
+    "",
+    "Project-owned files",
+    plan.baselines.available
+      ? `  ${plan.baselines.removed.length ? "→" : "✓"} ${formatCount(plan.baselines.removed.length, "old baseline generation")} selected; keeping ${plan.baselines.retained.length}`
+      : "  ○ No active baseline found",
+    "",
+    "Disposable runtime",
+    !plan.runtime.detected
+      ? "  ✓ No runtime found"
+      : plan.runtime.included
+        ? "  → Current project runtime selected"
+        : "  ○ Current project runtime preserved (add --include-runtime to select it)",
+    "",
+    "Shared Docker images",
+    !plan.images.requested
+      ? "  ○ Not inspected (add --include-images to inspect older unused Supabase images)"
+      : !plan.images.inspected
+        ? "  ! Docker is unavailable; images could not be inspected"
+        : plan.images.candidates.length
+          ? `  → ${formatCount(plan.images.candidates.length, "older unused Supabase image")} selected; approximately ${formatBytes(imageBytes)}`
+          : "  ✓ No older unused Supabase images found",
+    ...(plan.images.candidates.length
+      ? plan.images.candidates.flatMap((image) =>
+          image.tags.map((tag) => `    ${tag}`),
+        )
+      : []),
+    "",
+    ...(result.mode === "preview"
+      ? selectedCount
+        ? [
+            "Nothing has been removed.",
+            `Cleanup set: ${plan.digest.slice(0, 12)}`,
+            `Exact confirmation: --confirm-cleanup=${plan.digest}`,
+            "Review this list, then rerun the same command with --write and the exact confirmation above.",
+          ]
+        : [
+            "Nothing has been removed, and nothing is currently selected.",
+            "Use --include-runtime or --include-images only when you want those shared resources considered.",
+          ]
+      : [
+          `Removed ${formatCount(result.applied.baselines.removed.length, "old baseline generation")}.`,
+          result.applied.runtimeRemoved
+            ? "Removed this project's disposable runtime and volumes."
+            : "Preserved this project's disposable runtime.",
+          `Removed ${formatCount(result.applied.imagesRemoved.length, "unused image tag")}.`,
+        ]),
+  ].join("\n");
+};
+
+const runCleanup = async ({ flags, planOptions }) => {
+  const plan =
+    flags.cleanupPlan ??
+    (await planRehearsalCleanup({
+      ...planOptions,
+      includeRuntime: flags.includeRuntime,
+      includeImages: flags.includeImages,
+    }));
+  if (!flags.write) return { mode: "preview", plan };
+  const applied = await applyRehearsalCleanup({
+    plan,
+    confirmation: flags.cleanupConfirmation,
+    ...planOptions,
+    removeRuntime: async () => {
+      runManager({ action: "discard", flags });
+    },
+  });
+  return { mode: "written", plan, applied };
+};
+
 const usage = () => `Usage: rehearsal <command> [options]
 
 Commands:
   guide                       Open the interactive, state-aware home screen
-  setup [--write]             Preview or create safe first-run scaffolding
+  setup [--target=] [--write] Preview or create safe first-run scaffolding
   init [--write]              Preview or explicitly write safe starter config
   baseline prepare --records= --ledger= [--write] Create a fail-closed policy draft
   baseline create --records= --ledger= [--assets=] Create a baseline from safe local inputs
@@ -1589,9 +1843,11 @@ Commands:
   status                     Report the disposable local runtime state
   stop                       Stop only this project's local runtime
   discard                    Remove only this project's disposable runtime
+  cleanup [--include-runtime] [--include-images] [--write] [--confirm-cleanup=]
+                             Preview or apply conservative disk cleanup
   verify                     Verify the current local Rehearsal runtime
 
-Options: --json --verbose --debug --plain --config=<path>`;
+Options: --json --verbose --debug --plain --config=<path> --target=supabase|postgresql`;
 
 const executeCommand = async ({ command, flags, planOptions, guided }) => {
   if (command === "help" || flags.help) {
@@ -1663,6 +1919,11 @@ const executeCommand = async ({ command, flags, planOptions, guided }) => {
     emit({ command, data, flags, render: renderSupportReport });
     return;
   }
+  if (command === "cleanup") {
+    const data = await runCleanup({ flags, planOptions });
+    emit({ command, data, flags, render: renderCleanup });
+    return;
+  }
   if (command === "explain" || (command === "run" && flags.dryRun)) {
     const data = await buildRehearsalPlan(planOptions);
     emit({ command, data, flags, render: renderPlan });
@@ -1797,8 +2058,41 @@ const resetGuidedFlags = (flags) => {
   flags.recordsPath = undefined;
   flags.ledgerPath = undefined;
   flags.assetsPath = undefined;
+  flags.target = undefined;
+  flags.includeRuntime = false;
+  flags.includeImages = false;
+  flags.cleanupConfirmation = undefined;
   flags.setupPlan = undefined;
   flags.preparationPlan = undefined;
+  flags.cleanupPlan = undefined;
+};
+
+const installGuidedExitShortcut = (flags) => {
+  let exiting = false;
+  const exit = () => {
+    if (exiting) return;
+    exiting = true;
+    if (process.stdin.isTTY && process.stdin.isRaw) {
+      process.stdin.setRawMode(false);
+    }
+    process.stdout.write("\u001B[?25h");
+    if (useStyledPrompts(flags)) {
+      prompts.outro("Rehearsal exited.");
+    } else {
+      console.log("\nRehearsal exited.");
+    }
+    process.exit(0);
+  };
+  const onInput = (chunk) => {
+    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    if (bytes.includes(0x1a)) exit();
+  };
+  process.stdin.prependListener("data", onInput);
+  process.prependListener("SIGTSTP", exit);
+  return () => {
+    process.stdin.removeListener("data", onInput);
+    process.removeListener("SIGTSTP", exit);
+  };
 };
 
 const main = async () => {
@@ -1825,20 +2119,25 @@ const main = async () => {
     );
   }
   flags.guided = true;
+  const removeGuidedExitShortcut = installGuidedExitShortcut(flags);
   if (useStyledPrompts(flags)) {
     prompts.intro("REHEARSAL · Safe local migration testing");
   }
-  while (true) {
-    resetGuidedFlags(flags);
-    const selected = await runGuidedHome({ flags, planOptions });
-    if (!selected) break;
-    if (selected === "refresh") continue;
-    await executeCommand({
-      command: selected,
-      flags,
-      planOptions,
-      guided: true,
-    });
+  try {
+    while (true) {
+      resetGuidedFlags(flags);
+      const selected = await runGuidedHome({ flags, planOptions });
+      if (!selected) break;
+      if (selected === "refresh") continue;
+      await executeCommand({
+        command: selected,
+        flags,
+        planOptions,
+        guided: true,
+      });
+    }
+  } finally {
+    removeGuidedExitShortcut();
   }
   if (useStyledPrompts(flags)) {
     prompts.outro("See you at the next rehearsal.");