chainlesschain 0.66.0 → 0.81.0

package/src/commands/sla.js

@@ -21,6 +21,25 @@ import {
   generateReport,
   SLA_TERMS,
   VIOLATION_SEVERITY,
+  // V2
+  SLA_STATUS_V2,
+  SLA_TIER_V2,
+  SLA_TERM_V2,
+  VIOLATION_SEVERITY_V2,
+  VIOLATION_STATUS_V2,
+  SLA_DEFAULT_MAX_ACTIVE_PER_ORG,
+  setMaxActiveSlasPerOrg,
+  getMaxActiveSlasPerOrg,
+  getActiveSlaCountForOrg,
+  createSLAV2,
+  setSLAStatus,
+  expireSLA,
+  autoExpireSLAs,
+  setViolationStatus,
+  acknowledgeViolation,
+  resolveViolation,
+  waiveViolation,
+  getSLAStatsV2,
 } from "../lib/sla-manager.js";
 
 function _dbFromCtx(ctx) {
@@ -349,4 +368,244 @@ export function registerSlaCommand(program) {
         process.exit(1);
       }
     });
+
+  // ---------- V2 (Phase 61) ----------
+  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();
+      ensureSlaTables(db);
+      return await fn(db);
+    } finally {
+      await shutdown();
+    }
+  };
+
+  sla
+    .command("statuses")
+    .description("List SLA_STATUS_V2 values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(SLA_STATUS_V2), null, 2));
+    });
+
+  sla
+    .command("tier-names")
+    .description("List SLA_TIER_V2 values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(SLA_TIER_V2), null, 2));
+    });
+
+  sla
+    .command("term-names")
+    .description("List SLA_TERM_V2 values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(SLA_TERM_V2), null, 2));
+    });
+
+  sla
+    .command("severities")
+    .description("List VIOLATION_SEVERITY_V2 values")
+    .action(() => {
+      console.log(
+        JSON.stringify(Object.values(VIOLATION_SEVERITY_V2), null, 2),
+      );
+    });
+
+  sla
+    .command("violation-statuses")
+    .description("List VIOLATION_STATUS_V2 values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(VIOLATION_STATUS_V2), null, 2));
+    });
+
+  sla
+    .command("default-max-active")
+    .description("Show SLA_DEFAULT_MAX_ACTIVE_PER_ORG")
+    .action(() => {
+      console.log(SLA_DEFAULT_MAX_ACTIVE_PER_ORG);
+    });
+
+  sla
+    .command("max-active")
+    .description("Show current max active SLAs per org")
+    .action(() => {
+      console.log(getMaxActiveSlasPerOrg());
+    });
+
+  sla
+    .command("set-max-active <n>")
+    .description("Set per-org active-contract admission cap")
+    .action((n) => {
+      try {
+        const v = setMaxActiveSlasPerOrg(Number(n));
+        logger.success(`maxActiveSlasPerOrg=${v}`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  sla
+    .command("active-count <org-id>")
+    .description("Show active SLA count for an org")
+    .action((orgId) => {
+      console.log(getActiveSlaCountForOrg(orgId));
+    });
+
+  sla
+    .command("create-v2 <org-id>")
+    .description("Create a V2 SLA contract (enforces per-org active cap)")
+    .option("-t, --tier <tier>", "gold|silver|bronze", "silver")
+    .option("-d, --duration <ms>", "Contract duration in ms", parseInt)
+    .option("-f, --fee <amount>", "Monthly fee", parseFloat)
+    .option("--json", "Output as JSON")
+    .action(async (orgId, options) => {
+      try {
+        await withDb((db) => {
+          const c = createSLAV2(db, {
+            orgId,
+            tier: options.tier,
+            duration: options.duration,
+            monthlyFee: options.fee,
+          });
+          if (options.json) {
+            console.log(JSON.stringify(c, null, 2));
+          } else {
+            logger.success(
+              `Created ${c.slaId.slice(0, 8)} [${c.tier}] → ${c.status}`,
+            );
+          }
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  sla
+    .command("set-status <sla-id> <status>")
+    .description("Transition SLA to a given status (state-machine guarded)")
+    .action(async (slaId, status) => {
+      try {
+        await withDb((db) => {
+          const c = setSLAStatus(db, slaId, status);
+          logger.success(`${c.slaId.slice(0, 8)} → ${c.status}`);
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  sla
+    .command("expire <sla-id>")
+    .description("Expire an SLA (shortcut for set-status ... expired)")
+    .action(async (slaId) => {
+      try {
+        await withDb((db) => {
+          const c = expireSLA(db, slaId);
+          logger.success(`${c.slaId.slice(0, 8)} → ${c.status}`);
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  sla
+    .command("auto-expire")
+    .description("Bulk-flip ACTIVE contracts past endDate to EXPIRED")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        await withDb((db) => {
+          const flipped = autoExpireSLAs(db);
+          if (options.json) {
+            console.log(JSON.stringify(flipped, null, 2));
+          } else {
+            logger.success(`Auto-expired ${flipped.length} contract(s)`);
+          }
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  sla
+    .command("set-violation-status <violation-id> <status>")
+    .description("Transition a violation (open→{acknowledged,resolved,waived})")
+    .option("--note <note>", "Attach a note")
+    .action(async (violationId, status, options) => {
+      try {
+        await withDb((db) => {
+          const v = setViolationStatus(db, violationId, status, {
+            note: options.note,
+          });
+          logger.success(`${v.violationId.slice(0, 8)} → ${v.v2Status}`);
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  sla
+    .command("acknowledge-violation <violation-id>")
+    .description("Acknowledge a violation")
+    .option("--note <note>", "Attach a note")
+    .action(async (violationId, options) => {
+      try {
+        await withDb((db) => {
+          const v = acknowledgeViolation(db, violationId, options.note);
+          logger.success(`${v.violationId.slice(0, 8)} → ${v.v2Status}`);
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  sla
+    .command("resolve-violation <violation-id>")
+    .description("Resolve a violation")
+    .option("--note <note>", "Attach a note")
+    .action(async (violationId, options) => {
+      try {
+        await withDb((db) => {
+          const v = resolveViolation(db, violationId, options.note);
+          logger.success(`${v.violationId.slice(0, 8)} → ${v.v2Status}`);
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  sla
+    .command("waive-violation <violation-id>")
+    .description("Waive a violation")
+    .option("--note <note>", "Attach a note")
+    .action(async (violationId, options) => {
+      try {
+        await withDb((db) => {
+          const v = waiveViolation(db, violationId, options.note);
+          logger.success(`${v.violationId.slice(0, 8)} → ${v.v2Status}`);
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  sla
+    .command("stats-v2")
+    .description("Show aggregate V2 SLA stats (byStatus/byTier/violations)")
+    .action(() => {
+      console.log(JSON.stringify(getSLAStatsV2(), null, 2));
+    });
 }

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));
+    });
 }