chainlesschain 0.66.0 → 0.81.0

package/src/lib/stress-tester.js

@@ -380,4 +380,334 @@ export function _resetState() {
   _runs.clear();
   _results.clear();
   _seq = 0;
+  _maxConcurrentTests = DEFAULT_MAX_CONCURRENT_TESTS;
+}
+
+/* ═══════════════════════════════════════════════════════════════
+ * V2 Canonical Surface (Phase 59 — Federation Stress Test)
+ *   Strictly additive; legacy exports above remain unchanged.
+ * ═══════════════════════════════════════════════════════════════ */
+
+export const RUN_STATUS_V2 = Object.freeze({
+  RUNNING: "running",
+  COMPLETE: "complete",
+  STOPPED: "stopped",
+  FAILED: "failed",
+});
+
+export const LEVEL_NAME_V2 = Object.freeze({
+  LIGHT: "light",
+  MEDIUM: "medium",
+  HEAVY: "heavy",
+  EXTREME: "extreme",
+});
+
+export const BOTTLENECK_KIND_V2 = Object.freeze({
+  ERROR_RATE: "error-rate",
+  TAIL_LATENCY: "tail-latency",
+  RESPONSE_TIME: "response-time",
+  THROUGHPUT: "throughput",
+});
+
+export const BOTTLENECK_SEVERITY_V2 = Object.freeze({
+  LOW: "low",
+  MEDIUM: "medium",
+  HIGH: "high",
+});
+
+const DEFAULT_MAX_CONCURRENT_TESTS = 3;
+let _maxConcurrentTests = DEFAULT_MAX_CONCURRENT_TESTS;
+
+export const STRESS_DEFAULT_MAX_CONCURRENT = DEFAULT_MAX_CONCURRENT_TESTS;
+
+export function setMaxConcurrentTests(n) {
+  if (typeof n !== "number" || !Number.isFinite(n) || n < 1) {
+    throw new Error("maxConcurrentTests must be a positive integer");
+  }
+  _maxConcurrentTests = Math.floor(n);
+  return _maxConcurrentTests;
+}
+
+export function getMaxConcurrentTests() {
+  return _maxConcurrentTests;
+}
+
+const _terminalRunStatuses = new Set([
+  RUN_STATUS_V2.COMPLETE,
+  RUN_STATUS_V2.STOPPED,
+  RUN_STATUS_V2.FAILED,
+]);
+
+// Run state machine: running → { complete, stopped, failed }
+const _allowedRunTransitions = new Map([
+  [
+    RUN_STATUS_V2.RUNNING,
+    new Set([
+      RUN_STATUS_V2.COMPLETE,
+      RUN_STATUS_V2.STOPPED,
+      RUN_STATUS_V2.FAILED,
+    ]),
+  ],
+  [RUN_STATUS_V2.COMPLETE, new Set([])],
+  [RUN_STATUS_V2.STOPPED, new Set([])],
+  [RUN_STATUS_V2.FAILED, new Set([])],
+]);
+
+export function getActiveTestCount() {
+  let count = 0;
+  for (const r of _runs.values()) {
+    if (r.status === RUN_STATUS_V2.RUNNING) count++;
+  }
+  return count;
+}
+
+/**
+ * startStressTestV2 — asynchronous lifecycle variant. Creates the run row in
+ * RUNNING state without computing metrics; caller is expected to call
+ * completeStressTest, stopStressTestV2, or failStressTest afterwards.
+ */
+export function startStressTestV2(db, config = {}) {
+  const levelName = config.level || LEVEL_NAME_V2.MEDIUM;
+  const level = resolveLevel(levelName);
+  if (!level) {
+    throw new Error(
+      `Unknown load level: ${levelName} (known: ${Object.values(LEVEL_NAME_V2).join("/")})`,
+    );
+  }
+
+  const concurrency = Number(config.concurrency ?? level.concurrency);
+  const requestsPerSecond = Number(
+    config.requestsPerSecond ?? level.requestsPerSecond,
+  );
+  const duration = Number(config.duration ?? level.duration);
+  if (concurrency <= 0 || duration <= 0 || requestsPerSecond <= 0) {
+    throw new Error("concurrency/duration/requestsPerSecond must all be > 0");
+  }
+
+  const activeCount = getActiveTestCount();
+  if (activeCount >= _maxConcurrentTests) {
+    throw new Error(
+      `Max concurrent stress tests reached: ${activeCount}/${_maxConcurrentTests}`,
+    );
+  }
+
+  const testId = crypto.randomUUID();
+  const now = Date.now();
+
+  const run = {
+    testId,
+    loadLevel: level.name,
+    concurrency,
+    requestsPerSecond,
+    duration,
+    status: RUN_STATUS_V2.RUNNING,
+    startedAt: now,
+    completedAt: null,
+    errorMessage: null,
+    _seq: ++_seq,
+  };
+
+  _runs.set(testId, run);
+  db.prepare(
+    `INSERT INTO stress_test_runs (test_id, load_level, concurrency, requests_per_second, duration, status, started_at, completed_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    testId,
+    level.name,
+    concurrency,
+    requestsPerSecond,
+    duration,
+    run.status,
+    now,
+    null,
+  );
+
+  const { _seq: _omit, ...rest } = run;
+  void _omit;
+  return rest;
+}
+
+export function completeStressTest(db, testId) {
+  const run = _runs.get(testId);
+  if (!run) throw new Error(`Stress test not found: ${testId}`);
+
+  const allowed = _allowedRunTransitions.get(run.status);
+  if (!allowed || !allowed.has(RUN_STATUS_V2.COMPLETE)) {
+    throw new Error(`Invalid run status transition: ${run.status} → complete`);
+  }
+
+  const seed = _hashSeed(testId);
+  const metrics = _synthesizeMetrics(
+    {
+      concurrency: run.concurrency,
+      requestsPerSecond: run.requestsPerSecond,
+      duration: run.duration,
+    },
+    seed,
+  );
+  const bottlenecks = _deriveBottlenecks(metrics, {
+    requestsPerSecond: run.requestsPerSecond,
+  });
+  const recommendations = _capacityRecommendations(
+    metrics,
+    { requestsPerSecond: run.requestsPerSecond },
+    bottlenecks,
+  );
+
+  const now = Date.now();
+  const resultId = crypto.randomUUID();
+  const result = {
+    resultId,
+    testId,
+    ...metrics,
+    bottlenecks,
+    capacityRecommendations: recommendations,
+    createdAt: now,
+  };
+  _results.set(testId, result);
+
+  db.prepare(
+    `INSERT INTO stress_test_results (result_id, test_id, tps, avg_response_time, p50_response_time, p95_response_time, p99_response_time, error_rate, bottlenecks, capacity_recommendations, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    resultId,
+    testId,
+    metrics.tps,
+    metrics.avgResponseTime,
+    metrics.p50ResponseTime,
+    metrics.p95ResponseTime,
+    metrics.p99ResponseTime,
+    metrics.errorRate,
+    JSON.stringify(bottlenecks),
+    JSON.stringify(recommendations),
+    now,
+  );
+
+  run.status = RUN_STATUS_V2.COMPLETE;
+  run.completedAt = now;
+  db.prepare(
+    `UPDATE stress_test_runs SET status = ?, completed_at = ? WHERE test_id = ?`,
+  ).run(RUN_STATUS_V2.COMPLETE, now, testId);
+
+  const { _seq: _omit, ...rest } = run;
+  void _omit;
+  return { ...rest, result };
+}
+
+export function stopStressTestV2(db, testId) {
+  return setRunStatus(db, testId, RUN_STATUS_V2.STOPPED);
+}
+
+export function failStressTest(db, testId, errorMessage) {
+  return setRunStatus(db, testId, RUN_STATUS_V2.FAILED, { errorMessage });
+}
+
+export function setRunStatus(db, testId, newStatus, patch = {}) {
+  const run = _runs.get(testId);
+  if (!run) throw new Error(`Stress test not found: ${testId}`);
+
+  const validStatuses = Object.values(RUN_STATUS_V2);
+  if (!validStatuses.includes(newStatus)) {
+    throw new Error(`Unknown run status: ${newStatus}`);
+  }
+
+  const allowed = _allowedRunTransitions.get(run.status);
+  if (!allowed || !allowed.has(newStatus)) {
+    throw new Error(
+      `Invalid run status transition: ${run.status} → ${newStatus}`,
+    );
+  }
+
+  run.status = newStatus;
+  if (typeof patch.errorMessage === "string") {
+    run.errorMessage = patch.errorMessage;
+  }
+  if (_terminalRunStatuses.has(newStatus)) {
+    run.completedAt = Date.now();
+  }
+
+  db.prepare(
+    `UPDATE stress_test_runs SET status = ?, completed_at = ? WHERE test_id = ?`,
+  ).run(newStatus, run.completedAt, testId);
+
+  const { _seq: _omit, ...rest } = run;
+  void _omit;
+  return rest;
+}
+
+/**
+ * recommendLevelV2 — suggest the largest pre-defined level whose targetRps is
+ * still ≤ the caller's target. Returns `light` for any sub-light target,
+ * `extreme` for anything ≥ extreme.
+ */
+export function recommendLevelV2(targetRps) {
+  if (
+    typeof targetRps !== "number" ||
+    !Number.isFinite(targetRps) ||
+    targetRps <= 0
+  ) {
+    throw new Error("targetRps must be a positive number");
+  }
+  const levels = Object.values(LOAD_LEVELS)
+    .slice()
+    .sort((a, b) => a.requestsPerSecond - b.requestsPerSecond);
+  let chosen = levels[0];
+  for (const level of levels) {
+    if (targetRps >= level.requestsPerSecond) chosen = level;
+  }
+  return { ...chosen };
+}
+
+export function getStressStatsV2() {
+  const runs = [..._runs.values()];
+  const results = [..._results.values()];
+
+  const byStatus = {};
+  for (const s of Object.values(RUN_STATUS_V2)) byStatus[s] = 0;
+  for (const r of runs) byStatus[r.status] = (byStatus[r.status] || 0) + 1;
+
+  const byLevel = {};
+  for (const l of Object.values(LEVEL_NAME_V2)) byLevel[l] = 0;
+  for (const r of runs) byLevel[r.loadLevel] = (byLevel[r.loadLevel] || 0) + 1;
+
+  const byKind = {};
+  for (const k of Object.values(BOTTLENECK_KIND_V2)) byKind[k] = 0;
+  const bySeverity = {};
+  for (const s of Object.values(BOTTLENECK_SEVERITY_V2)) bySeverity[s] = 0;
+
+  let totalTps = 0;
+  let totalP95 = 0;
+  let metricSamples = 0;
+  let totalBottlenecks = 0;
+
+  for (const result of results) {
+    totalTps += result.tps || 0;
+    totalP95 += result.p95ResponseTime || 0;
+    metricSamples++;
+    for (const b of result.bottlenecks || []) {
+      totalBottlenecks++;
+      if (byKind[b.kind] !== undefined) byKind[b.kind]++;
+      if (bySeverity[b.severity] !== undefined) bySeverity[b.severity]++;
+    }
+  }
+
+  return {
+    totalTests: runs.length,
+    activeTests: getActiveTestCount(),
+    maxConcurrentTests: _maxConcurrentTests,
+    byStatus,
+    byLevel,
+    bottlenecks: {
+      total: totalBottlenecks,
+      byKind,
+      bySeverity,
+    },
+    aggregateMetrics: {
+      samples: metricSamples,
+      avgTps:
+        metricSamples > 0 ? Number((totalTps / metricSamples).toFixed(2)) : 0,
+      avgP95:
+        metricSamples > 0 ? Number((totalP95 / metricSamples).toFixed(2)) : 0,
+    },
+  };
 }

package/src/lib/terraform-manager.js

@@ -198,4 +198,367 @@ export function listRuns(filter = {}) {
 export function _resetState() {
   _workspaces.clear();
   _runs.clear();
+  _maxConcurrentRuns = DEFAULT_MAX_CONCURRENT_RUNS;
+}
+
+/* ═══════════════════════════════════════════════════════════════
+ * V2 Canonical Surface (Phase 56 — Terraform Manager)
+ *   Strictly additive; legacy exports above remain unchanged.
+ * ═══════════════════════════════════════════════════════════════ */
+
+export const RUN_STATUS_V2 = Object.freeze({
+  PENDING: "pending",
+  PLANNING: "planning",
+  PLANNED: "planned",
+  APPLYING: "applying",
+  APPLIED: "applied",
+  DESTROYING: "destroying",
+  DESTROYED: "destroyed",
+  ERRORED: "errored",
+  CANCELLED: "cancelled",
+});
+
+export const RUN_TYPE_V2 = Object.freeze({
+  PLAN: "plan",
+  APPLY: "apply",
+  DESTROY: "destroy",
+});
+
+export const WORKSPACE_STATUS_V2 = Object.freeze({
+  ACTIVE: "active",
+  LOCKED: "locked",
+  ARCHIVED: "archived",
+});
+
+const DEFAULT_MAX_CONCURRENT_RUNS = 5;
+let _maxConcurrentRuns = DEFAULT_MAX_CONCURRENT_RUNS;
+
+export const TERRAFORM_DEFAULT_MAX_CONCURRENT = DEFAULT_MAX_CONCURRENT_RUNS;
+
+export function setMaxConcurrentRuns(n) {
+  if (typeof n !== "number" || !Number.isFinite(n) || n < 1) {
+    throw new Error("maxConcurrentRuns must be a positive integer");
+  }
+  _maxConcurrentRuns = Math.floor(n);
+  return _maxConcurrentRuns;
+}
+
+export function getMaxConcurrentRuns() {
+  return _maxConcurrentRuns;
+}
+
+const _activeRunStatuses = new Set([
+  RUN_STATUS_V2.PENDING,
+  RUN_STATUS_V2.PLANNING,
+  RUN_STATUS_V2.APPLYING,
+  RUN_STATUS_V2.DESTROYING,
+]);
+
+const _terminalRunStatuses = new Set([
+  RUN_STATUS_V2.APPLIED,
+  RUN_STATUS_V2.DESTROYED,
+  RUN_STATUS_V2.ERRORED,
+  RUN_STATUS_V2.CANCELLED,
+]);
+
+// run-status state machine
+const _allowedRunTransitions = new Map([
+  [
+    RUN_STATUS_V2.PENDING,
+    new Set([
+      RUN_STATUS_V2.PLANNING,
+      RUN_STATUS_V2.CANCELLED,
+      RUN_STATUS_V2.ERRORED,
+    ]),
+  ],
+  [
+    RUN_STATUS_V2.PLANNING,
+    new Set([
+      RUN_STATUS_V2.PLANNED,
+      RUN_STATUS_V2.ERRORED,
+      RUN_STATUS_V2.CANCELLED,
+    ]),
+  ],
+  [
+    RUN_STATUS_V2.PLANNED,
+    new Set([
+      RUN_STATUS_V2.APPLYING,
+      RUN_STATUS_V2.DESTROYING,
+      RUN_STATUS_V2.CANCELLED,
+      RUN_STATUS_V2.ERRORED,
+    ]),
+  ],
+  [
+    RUN_STATUS_V2.APPLYING,
+    new Set([RUN_STATUS_V2.APPLIED, RUN_STATUS_V2.ERRORED]),
+  ],
+  [
+    RUN_STATUS_V2.DESTROYING,
+    new Set([RUN_STATUS_V2.DESTROYED, RUN_STATUS_V2.ERRORED]),
+  ],
+  [RUN_STATUS_V2.APPLIED, new Set([])],
+  [RUN_STATUS_V2.DESTROYED, new Set([])],
+  [RUN_STATUS_V2.ERRORED, new Set([])],
+  [RUN_STATUS_V2.CANCELLED, new Set([])],
+]);
+
+// workspace-status state machine
+const _allowedWorkspaceTransitions = new Map([
+  [
+    WORKSPACE_STATUS_V2.ACTIVE,
+    new Set([WORKSPACE_STATUS_V2.LOCKED, WORKSPACE_STATUS_V2.ARCHIVED]),
+  ],
+  [
+    WORKSPACE_STATUS_V2.LOCKED,
+    new Set([WORKSPACE_STATUS_V2.ACTIVE, WORKSPACE_STATUS_V2.ARCHIVED]),
+  ],
+  [WORKSPACE_STATUS_V2.ARCHIVED, new Set([WORKSPACE_STATUS_V2.ACTIVE])],
+]);
+
+export function createWorkspaceV2(db, options = {}) {
+  const {
+    name,
+    description,
+    terraformVersion,
+    workingDirectory,
+    autoApply,
+    variables,
+    providers,
+  } = options;
+
+  if (!name) throw new Error("Workspace name is required");
+
+  // Unique name check
+  for (const existing of _workspaces.values()) {
+    if (existing.name === name) {
+      throw new Error(`Workspace name already exists: ${name}`);
+    }
+  }
+
+  return createWorkspace(db, name, {
+    description,
+    terraformVersion,
+    workingDirectory,
+    autoApply,
+    variables,
+    providers,
+  });
+}
+
+export function setWorkspaceStatus(db, workspaceId, newStatus) {
+  const workspace = _workspaces.get(workspaceId);
+  if (!workspace) throw new Error(`Workspace not found: ${workspaceId}`);
+
+  const validStatuses = Object.values(WORKSPACE_STATUS_V2);
+  if (!validStatuses.includes(newStatus)) {
+    throw new Error(`Unknown workspace status: ${newStatus}`);
+  }
+
+  const allowed = _allowedWorkspaceTransitions.get(workspace.status);
+  if (!allowed || !allowed.has(newStatus)) {
+    throw new Error(
+      `Invalid workspace status transition: ${workspace.status} → ${newStatus}`,
+    );
+  }
+
+  workspace.status = newStatus;
+  db.prepare(`UPDATE terraform_workspaces SET status = ? WHERE id = ?`).run(
+    newStatus,
+    workspaceId,
+  );
+
+  return { workspaceId, status: newStatus };
+}
+
+export function archiveWorkspace(db, workspaceId) {
+  return setWorkspaceStatus(db, workspaceId, WORKSPACE_STATUS_V2.ARCHIVED);
+}
+
+function _countActiveRuns() {
+  let count = 0;
+  for (const r of _runs.values()) {
+    if (_activeRunStatuses.has(r.status)) count++;
+  }
+  return count;
+}
+
+export function planRunV2(db, options = {}) {
+  const { workspaceId, runType, triggeredBy } = options;
+  const workspace = _workspaces.get(workspaceId);
+  if (!workspace) throw new Error(`Workspace not found: ${workspaceId}`);
+
+  const validRunTypes = Object.values(RUN_TYPE_V2);
+  const effectiveType = runType || RUN_TYPE_V2.PLAN;
+  if (!validRunTypes.includes(effectiveType)) {
+    throw new Error(`Unknown run type: ${effectiveType}`);
+  }
+
+  if (workspace.status === WORKSPACE_STATUS_V2.ARCHIVED) {
+    throw new Error(`Cannot plan run on archived workspace: ${workspaceId}`);
+  }
+
+  const activeCount = _countActiveRuns();
+  if (activeCount >= _maxConcurrentRuns) {
+    throw new Error(
+      `Max concurrent runs reached: ${activeCount}/${_maxConcurrentRuns}`,
+    );
+  }
+
+  const id = crypto.randomUUID();
+  const now = new Date().toISOString();
+
+  const run = {
+    id,
+    workspaceId,
+    runType: effectiveType,
+    status: RUN_STATUS_V2.PENDING,
+    planOutput: null,
+    applyOutput: null,
+    resourcesAdded: 0,
+    resourcesChanged: 0,
+    resourcesDestroyed: 0,
+    triggeredBy: triggeredBy || "manual",
+    startedAt: now,
+    completedAt: null,
+    errorMessage: null,
+    createdAt: now,
+  };
+
+  _runs.set(id, run);
+
+  db.prepare(
+    `INSERT INTO terraform_runs (id, workspace_id, run_type, status, plan_output, apply_output, resources_added, resources_changed, resources_destroyed, triggered_by, started_at, completed_at, error_message, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    id,
+    workspaceId,
+    effectiveType,
+    run.status,
+    null,
+    null,
+    0,
+    0,
+    0,
+    run.triggeredBy,
+    now,
+    null,
+    null,
+    now,
+  );
+
+  return run;
+}
+
+export function setRunStatus(db, runId, newStatus, patch = {}) {
+  const run = _runs.get(runId);
+  if (!run) throw new Error(`Run not found: ${runId}`);
+
+  const validStatuses = Object.values(RUN_STATUS_V2);
+  if (!validStatuses.includes(newStatus)) {
+    throw new Error(`Unknown run status: ${newStatus}`);
+  }
+
+  const allowed = _allowedRunTransitions.get(run.status);
+  if (!allowed || !allowed.has(newStatus)) {
+    throw new Error(
+      `Invalid run status transition: ${run.status} → ${newStatus}`,
+    );
+  }
+
+  run.status = newStatus;
+  if (typeof patch.planOutput === "string") run.planOutput = patch.planOutput;
+  if (typeof patch.applyOutput === "string")
+    run.applyOutput = patch.applyOutput;
+  if (typeof patch.resourcesAdded === "number")
+    run.resourcesAdded = patch.resourcesAdded;
+  if (typeof patch.resourcesChanged === "number")
+    run.resourcesChanged = patch.resourcesChanged;
+  if (typeof patch.resourcesDestroyed === "number")
+    run.resourcesDestroyed = patch.resourcesDestroyed;
+  if (typeof patch.errorMessage === "string")
+    run.errorMessage = patch.errorMessage;
+  if (_terminalRunStatuses.has(newStatus)) {
+    run.completedAt = new Date().toISOString();
+  }
+
+  db.prepare(
+    `UPDATE terraform_runs SET status = ?, plan_output = ?, apply_output = ?, resources_added = ?, resources_changed = ?, resources_destroyed = ?, error_message = ?, completed_at = ? WHERE id = ?`,
+  ).run(
+    run.status,
+    run.planOutput,
+    run.applyOutput,
+    run.resourcesAdded,
+    run.resourcesChanged,
+    run.resourcesDestroyed,
+    run.errorMessage,
+    run.completedAt,
+    runId,
+  );
+
+  // Bump workspace state version on terminal apply/destroy
+  if (
+    newStatus === RUN_STATUS_V2.APPLIED ||
+    newStatus === RUN_STATUS_V2.DESTROYED
+  ) {
+    const workspace = _workspaces.get(run.workspaceId);
+    if (workspace) {
+      workspace.stateVersion++;
+      workspace.lastRunId = runId;
+      workspace.lastRunAt = new Date().toISOString();
+    }
+  }
+
+  return run;
+}
+
+export function cancelRun(db, runId) {
+  return setRunStatus(db, runId, RUN_STATUS_V2.CANCELLED);
+}
+
+export function failRun(db, runId, errorMessage) {
+  return setRunStatus(db, runId, RUN_STATUS_V2.ERRORED, { errorMessage });
+}
+
+export function getActiveRunCount() {
+  return _countActiveRuns();
+}
+
+export function getTerraformStatsV2() {
+  const workspaces = [..._workspaces.values()];
+  const runs = [..._runs.values()];
+
+  const wsByStatus = {};
+  for (const s of Object.values(WORKSPACE_STATUS_V2)) wsByStatus[s] = 0;
+  for (const w of workspaces)
+    wsByStatus[w.status] = (wsByStatus[w.status] || 0) + 1;
+
+  const runsByStatus = {};
+  for (const s of Object.values(RUN_STATUS_V2)) runsByStatus[s] = 0;
+  for (const r of runs)
+    runsByStatus[r.status] = (runsByStatus[r.status] || 0) + 1;
+
+  const runsByType = {};
+  for (const t of Object.values(RUN_TYPE_V2)) runsByType[t] = 0;
+  for (const r of runs)
+    runsByType[r.runType] = (runsByType[r.runType] || 0) + 1;
+
+  const totalResources = runs.reduce(
+    (acc, r) => ({
+      added: acc.added + (r.resourcesAdded || 0),
+      changed: acc.changed + (r.resourcesChanged || 0),
+      destroyed: acc.destroyed + (r.resourcesDestroyed || 0),
+    }),
+    { added: 0, changed: 0, destroyed: 0 },
+  );
+
+  return {
+    totalWorkspaces: workspaces.length,
+    totalRuns: runs.length,
+    activeRuns: _countActiveRuns(),
+    maxConcurrentRuns: _maxConcurrentRuns,
+    workspacesByStatus: wsByStatus,
+    runsByStatus,
+    runsByType,
+    totalResources,
+  };
 }