chainlesschain 0.51.0 → 0.81.0

package/src/commands/stress.js

@@ -15,6 +15,22 @@ import {
   analyzeBottlenecks,
   generateCapacityPlan,
   listLoadLevels,
+  // V2
+  RUN_STATUS_V2,
+  LEVEL_NAME_V2,
+  BOTTLENECK_KIND_V2,
+  BOTTLENECK_SEVERITY_V2,
+  STRESS_DEFAULT_MAX_CONCURRENT,
+  setMaxConcurrentTests,
+  getMaxConcurrentTests,
+  getActiveTestCount,
+  startStressTestV2,
+  completeStressTest,
+  stopStressTestV2,
+  failStressTest,
+  setRunStatus,
+  recommendLevelV2,
+  getStressStatsV2,
 } from "../lib/stress-tester.js";
 
 function _dbFromCtx(ctx) {
@@ -249,4 +265,218 @@ export function registerStressCommand(program) {
         }
       }
     });
+
+  // ---------- V2 (Phase 59) ----------
+  const withDb = async (fn) => {
+    const ctx = await bootstrap({ verbose: program.opts().verbose });
+    if (!ctx.db) {
+      logger.error("Database not available");
+      process.exit(1);
+    }
+    try {
+      const db = ctx.db.getDatabase();
+      ensureStressTables(db);
+      return await fn(db);
+    } finally {
+      await shutdown();
+    }
+  };
+
+  stress
+    .command("run-statuses")
+    .description("List RUN_STATUS_V2 values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(RUN_STATUS_V2), null, 2));
+    });
+
+  stress
+    .command("level-names")
+    .description("List LEVEL_NAME_V2 values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(LEVEL_NAME_V2), null, 2));
+    });
+
+  stress
+    .command("bottleneck-kinds")
+    .description("List BOTTLENECK_KIND_V2 values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(BOTTLENECK_KIND_V2), null, 2));
+    });
+
+  stress
+    .command("bottleneck-severities")
+    .description("List BOTTLENECK_SEVERITY_V2 values")
+    .action(() => {
+      console.log(
+        JSON.stringify(Object.values(BOTTLENECK_SEVERITY_V2), null, 2),
+      );
+    });
+
+  stress
+    .command("default-max-concurrent")
+    .description("Show STRESS_DEFAULT_MAX_CONCURRENT")
+    .action(() => {
+      console.log(STRESS_DEFAULT_MAX_CONCURRENT);
+    });
+
+  stress
+    .command("max-concurrent")
+    .description("Show current max concurrent test limit")
+    .action(() => {
+      console.log(getMaxConcurrentTests());
+    });
+
+  stress
+    .command("active-test-count")
+    .description("Show current active (RUNNING) test count")
+    .action(() => {
+      console.log(getActiveTestCount());
+    });
+
+  stress
+    .command("set-max-concurrent <n>")
+    .description("Set max concurrent test admission limit")
+    .action((n) => {
+      try {
+        const v = setMaxConcurrentTests(Number(n));
+        logger.success(`maxConcurrentTests=${v}`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  stress
+    .command("start-v2")
+    .description("Start a V2 stress run (RUNNING, no metrics until complete)")
+    .option(
+      "-l, --level <level>",
+      "Load level (light|medium|heavy|extreme)",
+      "medium",
+    )
+    .option("-c, --concurrency <n>", "Override concurrency", parseInt)
+    .option("-r, --rps <n>", "Override requests per second", parseInt)
+    .option("-d, --duration <ms>", "Override duration in ms", parseInt)
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        await withDb((db) => {
+          const run = startStressTestV2(db, {
+            level: options.level,
+            concurrency: options.concurrency,
+            requestsPerSecond: options.rps,
+            duration: options.duration,
+          });
+          if (options.json) {
+            console.log(JSON.stringify(run, null, 2));
+          } else {
+            logger.success(
+              `Started ${run.testId.slice(0, 8)} [${run.loadLevel}] → ${run.status}`,
+            );
+          }
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  stress
+    .command("complete <test-id>")
+    .description("Complete a RUNNING run and compute metrics")
+    .option("--json", "Output as JSON")
+    .action(async (testId, options) => {
+      try {
+        await withDb((db) => {
+          const r = completeStressTest(db, testId);
+          if (options.json) {
+            console.log(JSON.stringify(r, null, 2));
+          } else {
+            logger.success(
+              `${r.testId.slice(0, 8)} → ${r.status} (tps=${r.result.tps})`,
+            );
+          }
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  stress
+    .command("stop-v2 <test-id>")
+    .description("Stop a RUNNING run (→ STOPPED)")
+    .action(async (testId) => {
+      try {
+        await withDb((db) => {
+          const r = stopStressTestV2(db, testId);
+          logger.success(`${r.testId.slice(0, 8)} → ${r.status}`);
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  stress
+    .command("fail <test-id> <error-message>")
+    .description("Fail a RUNNING run with an error message (→ FAILED)")
+    .action(async (testId, errorMessage) => {
+      try {
+        await withDb((db) => {
+          const r = failStressTest(db, testId, errorMessage);
+          logger.success(
+            `${r.testId.slice(0, 8)} → ${r.status} (${r.errorMessage})`,
+          );
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  stress
+    .command("set-status <test-id> <status>")
+    .description("Transition run to a given status (state-machine guarded)")
+    .option("--error-message <msg>", "Attach error message (for failed)")
+    .action(async (testId, status, options) => {
+      try {
+        await withDb((db) => {
+          const patch = {};
+          if (options.errorMessage) patch.errorMessage = options.errorMessage;
+          const r = setRunStatus(db, testId, status, patch);
+          logger.success(`${r.testId.slice(0, 8)} → ${r.status}`);
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  stress
+    .command("recommend-level <target-rps>")
+    .description("Recommend the largest built-in level ≤ targetRps")
+    .option("--json", "Output as JSON")
+    .action((targetRps, options) => {
+      try {
+        const level = recommendLevelV2(Number(targetRps));
+        if (options.json) {
+          console.log(JSON.stringify(level, null, 2));
+        } else {
+          logger.log(
+            `  ${chalk.cyan(level.name)}  concurrency=${level.concurrency} rps=${level.requestsPerSecond} duration=${level.duration}ms`,
+          );
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  stress
+    .command("stats-v2")
+    .description("Show aggregate V2 stats (byStatus/byLevel/bottlenecks)")
+    .action(() => {
+      console.log(JSON.stringify(getStressStatsV2(), null, 2));
+    });
 }

package/src/commands/terraform.js

@@ -12,6 +12,22 @@ import {
   createWorkspace,
   planRun,
   listRuns,
+  // V2
+  RUN_STATUS_V2,
+  RUN_TYPE_V2,
+  WORKSPACE_STATUS_V2,
+  TERRAFORM_DEFAULT_MAX_CONCURRENT,
+  setMaxConcurrentRuns,
+  getMaxConcurrentRuns,
+  createWorkspaceV2,
+  setWorkspaceStatus,
+  archiveWorkspace,
+  planRunV2,
+  setRunStatus,
+  cancelRun,
+  failRun,
+  getActiveRunCount,
+  getTerraformStatsV2,
 } from "../lib/terraform-manager.js";
 
 export function registerTerraformCommand(program) {
@@ -145,4 +161,233 @@ export function registerTerraformCommand(program) {
         process.exit(1);
       }
     });
+
+  /* ── V2 Subcommands (Phase 56) ──────────────────────────── */
+
+  const withDb = async (fn) => {
+    const ctx = await bootstrap({ verbose: program.opts().verbose });
+    if (!ctx.db) {
+      logger.error("Database not available");
+      process.exit(1);
+    }
+    try {
+      const db = ctx.db.getDatabase();
+      ensureTerraformTables(db);
+      return await fn(db);
+    } finally {
+      await shutdown();
+    }
+  };
+
+  terraform
+    .command("run-statuses")
+    .description("List RUN_STATUS_V2 enum values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(RUN_STATUS_V2), null, 2));
+    });
+
+  terraform
+    .command("run-types")
+    .description("List RUN_TYPE_V2 enum values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(RUN_TYPE_V2), null, 2));
+    });
+
+  terraform
+    .command("workspace-statuses")
+    .description("List WORKSPACE_STATUS_V2 enum values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(WORKSPACE_STATUS_V2), null, 2));
+    });
+
+  terraform
+    .command("default-max-concurrent")
+    .description("Show TERRAFORM_DEFAULT_MAX_CONCURRENT")
+    .action(() => {
+      console.log(TERRAFORM_DEFAULT_MAX_CONCURRENT);
+    });
+
+  terraform
+    .command("active-run-count")
+    .description("Show current active (non-terminal) run count")
+    .action(() => {
+      console.log(getActiveRunCount());
+    });
+
+  terraform
+    .command("set-max-concurrent <n>")
+    .description("Set max concurrent runs")
+    .action(async (n) => {
+      try {
+        const value = setMaxConcurrentRuns(Number(n));
+        logger.success(`maxConcurrentRuns = ${value}`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  terraform
+    .command("max-concurrent")
+    .description("Show current max concurrent runs")
+    .action(() => {
+      console.log(getMaxConcurrentRuns());
+    });
+
+  terraform
+    .command("create-workspace-v2 <name>")
+    .description("Create workspace (V2, unique-name enforced)")
+    .option("-d, --description <text>", "Workspace description")
+    .option("--tf-version <version>", "Terraform version")
+    .option("--auto-apply", "Enable auto-apply")
+    .option("--providers <list>", "Comma-separated providers")
+    .action(async (name, options) => {
+      await withDb(async (db) => {
+        try {
+          const ws = createWorkspaceV2(db, {
+            name,
+            description: options.description,
+            terraformVersion: options.tfVersion,
+            autoApply: options.autoApply,
+            providers: options.providers
+              ? options.providers.split(",").map((s) => s.trim())
+              : undefined,
+          });
+          logger.success("Workspace created (V2)");
+          logger.log(`  ID:     ${chalk.cyan(ws.id)}`);
+          logger.log(`  Name:   ${ws.name}`);
+          logger.log(`  Status: ${ws.status}`);
+        } catch (err) {
+          logger.error(`Failed: ${err.message}`);
+          process.exit(1);
+        }
+      });
+    });
+
+  terraform
+    .command("set-workspace-status <workspace-id> <status>")
+    .description("Set workspace status (state-machine guarded)")
+    .action(async (workspaceId, status) => {
+      await withDb(async (db) => {
+        try {
+          const result = setWorkspaceStatus(db, workspaceId, status);
+          logger.success(
+            `Workspace ${workspaceId.slice(0, 8)} → ${result.status}`,
+          );
+        } catch (err) {
+          logger.error(`Failed: ${err.message}`);
+          process.exit(1);
+        }
+      });
+    });
+
+  terraform
+    .command("archive-workspace <workspace-id>")
+    .description("Archive a workspace (shortcut)")
+    .action(async (workspaceId) => {
+      await withDb(async (db) => {
+        try {
+          const result = archiveWorkspace(db, workspaceId);
+          logger.success(`Workspace archived: ${result.status}`);
+        } catch (err) {
+          logger.error(`Failed: ${err.message}`);
+          process.exit(1);
+        }
+      });
+    });
+
+  terraform
+    .command("plan-run-v2 <workspace-id>")
+    .description("Create a V2 run (pending state, concurrency-limited)")
+    .option("-t, --run-type <type>", "Run type: plan|apply|destroy", "plan")
+    .option("--triggered-by <who>", "Who triggered the run")
+    .action(async (workspaceId, options) => {
+      await withDb(async (db) => {
+        try {
+          const run = planRunV2(db, {
+            workspaceId,
+            runType: options.runType,
+            triggeredBy: options.triggeredBy,
+          });
+          logger.success("Run created (V2)");
+          logger.log(`  ID:     ${chalk.cyan(run.id)}`);
+          logger.log(`  Type:   ${run.runType}`);
+          logger.log(`  Status: ${run.status}`);
+        } catch (err) {
+          logger.error(`Failed: ${err.message}`);
+          process.exit(1);
+        }
+      });
+    });
+
+  terraform
+    .command("set-run-status <run-id> <status>")
+    .description("Set run status (state-machine guarded)")
+    .option("--plan-output <text>", "Plan output summary")
+    .option("--apply-output <text>", "Apply output summary")
+    .option("--resources-added <n>", "Resources added count")
+    .option("--resources-changed <n>", "Resources changed count")
+    .option("--resources-destroyed <n>", "Resources destroyed count")
+    .option("--error-message <text>", "Error message")
+    .action(async (runId, status, options) => {
+      await withDb(async (db) => {
+        try {
+          const patch = {};
+          if (options.planOutput) patch.planOutput = options.planOutput;
+          if (options.applyOutput) patch.applyOutput = options.applyOutput;
+          if (options.resourcesAdded !== undefined)
+            patch.resourcesAdded = Number(options.resourcesAdded);
+          if (options.resourcesChanged !== undefined)
+            patch.resourcesChanged = Number(options.resourcesChanged);
+          if (options.resourcesDestroyed !== undefined)
+            patch.resourcesDestroyed = Number(options.resourcesDestroyed);
+          if (options.errorMessage) patch.errorMessage = options.errorMessage;
+          const run = setRunStatus(db, runId, status, patch);
+          logger.success(`Run ${runId.slice(0, 8)} → ${run.status}`);
+        } catch (err) {
+          logger.error(`Failed: ${err.message}`);
+          process.exit(1);
+        }
+      });
+    });
+
+  terraform
+    .command("cancel-run <run-id>")
+    .description("Cancel a run (shortcut)")
+    .action(async (runId) => {
+      await withDb(async (db) => {
+        try {
+          const run = cancelRun(db, runId);
+          logger.success(`Run cancelled: ${run.status}`);
+        } catch (err) {
+          logger.error(`Failed: ${err.message}`);
+          process.exit(1);
+        }
+      });
+    });
+
+  terraform
+    .command("fail-run <run-id> <error-message>")
+    .description("Mark a run as errored (shortcut)")
+    .action(async (runId, errorMessage) => {
+      await withDb(async (db) => {
+        try {
+          const run = failRun(db, runId, errorMessage);
+          logger.success(`Run errored: ${run.errorMessage}`);
+        } catch (err) {
+          logger.error(`Failed: ${err.message}`);
+          process.exit(1);
+        }
+      });
+    });
+
+  terraform
+    .command("stats-v2")
+    .description("Show V2 terraform stats")
+    .action(async () => {
+      await withDb(async () => {
+        const stats = getTerraformStatsV2();
+        console.log(JSON.stringify(stats, null, 2));
+      });
+    });
 }