chainlesschain 0.66.0 → 0.81.0

package/src/commands/reputation.js

@@ -18,6 +18,22 @@ import {
   listOptimizationRuns,
   applyOptimizedParams,
   OPTIMIZATION_OBJECTIVES,
+  // V2 (Phase 60)
+  RUN_STATUS_V2,
+  OBJECTIVE_V2,
+  DECAY_MODEL_V2,
+  ANOMALY_METHOD_V2,
+  REPUTATION_DEFAULT_MAX_CONCURRENT,
+  setMaxConcurrentOptimizations,
+  getMaxConcurrentOptimizations,
+  getActiveOptimizationCount,
+  startOptimizationV2,
+  completeOptimization,
+  cancelOptimization,
+  failOptimization,
+  applyOptimization,
+  setRunStatus,
+  getReputationStatsV2,
 } from "../lib/reputation-optimizer.js";
 
 function _dbFromCtx(ctx) {
@@ -346,4 +362,249 @@ export function registerReputationCommand(program) {
         for (const v of values) logger.log(`  ${chalk.cyan(v)}`);
       }
     });
+
+  /* ── V2 (Phase 60) ───────────────────────────────────────── */
+
+  rep
+    .command("run-statuses")
+    .description(
+      "List V2 run statuses (running/complete/applied/failed/cancelled)",
+    )
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const values = Object.values(RUN_STATUS_V2);
+      if (options.json) console.log(JSON.stringify(values, null, 2));
+      else for (const v of values) logger.log(`  ${chalk.cyan(v)}`);
+    });
+
+  rep
+    .command("v2-objectives")
+    .description("List V2 objectives (frozen enum)")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const values = Object.values(OBJECTIVE_V2);
+      if (options.json) console.log(JSON.stringify(values, null, 2));
+      else for (const v of values) logger.log(`  ${chalk.cyan(v)}`);
+    });
+
+  rep
+    .command("decay-models")
+    .description("List V2 decay models (frozen enum)")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const values = Object.values(DECAY_MODEL_V2);
+      if (options.json) console.log(JSON.stringify(values, null, 2));
+      else for (const v of values) logger.log(`  ${chalk.cyan(v)}`);
+    });
+
+  rep
+    .command("anomaly-methods")
+    .description("List V2 anomaly methods (frozen enum)")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const values = Object.values(ANOMALY_METHOD_V2);
+      if (options.json) console.log(JSON.stringify(values, null, 2));
+      else for (const v of values) logger.log(`  ${chalk.cyan(v)}`);
+    });
+
+  rep
+    .command("default-max-concurrent")
+    .description("Show default max concurrent optimizations")
+    .action(() => {
+      logger.log(`  ${REPUTATION_DEFAULT_MAX_CONCURRENT}`);
+    });
+
+  rep
+    .command("max-concurrent")
+    .description("Show current max concurrent optimizations")
+    .action(() => {
+      logger.log(`  ${getMaxConcurrentOptimizations()}`);
+    });
+
+  rep
+    .command("active-optimization-count")
+    .description("Show count of currently-RUNNING optimizations")
+    .action(() => {
+      logger.log(`  ${getActiveOptimizationCount()}`);
+    });
+
+  rep
+    .command("set-max-concurrent <n>")
+    .description("Set the concurrency cap for RUNNING optimizations")
+    .action((n) => {
+      try {
+        const v = setMaxConcurrentOptimizations(Number(n));
+        logger.success(`Max concurrent = ${v}`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  rep
+    .command("start-v2")
+    .description(
+      "Start a V2 optimization (RUNNING only, driven by complete/cancel/fail)",
+    )
+    .option(
+      "-o, --objective <name>",
+      "Objective (accuracy|fairness|resilience|convergence_speed)",
+      "accuracy",
+    )
+    .option("-i, --iterations <n>", "Iteration count", parseInt, 50)
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const run = startOptimizationV2(db, {
+          objective: options.objective,
+          iterations: options.iterations,
+        });
+        if (options.json) console.log(JSON.stringify(run, null, 2));
+        else {
+          logger.success(`Optimization started [${run.status}]`);
+          logger.log(`  ${chalk.bold("Run ID:")}     ${chalk.cyan(run.runId)}`);
+          logger.log(`  ${chalk.bold("Objective:")}  ${run.objective}`);
+          logger.log(`  ${chalk.bold("Iterations:")} ${run.iterations}`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  rep
+    .command("complete <run-id>")
+    .description(
+      "Complete a V2 optimization (RUNNING → COMPLETE, runs iterations)",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (runId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const result = completeOptimization(db, runId);
+        if (options.json) console.log(JSON.stringify(result, null, 2));
+        else {
+          logger.success(`Completed [${result.status}]`);
+          logger.log(`  ${chalk.bold("Best score:")}  ${result.bestScore}`);
+          logger.log(
+            `  ${chalk.bold("Best params:")} ${JSON.stringify(result.bestParams)}`,
+          );
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  rep
+    .command("cancel <run-id>")
+    .description("Cancel a V2 RUNNING optimization")
+    .action(async (runId) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const result = cancelOptimization(db, runId);
+        logger.success(`Cancelled [${result.status}]`);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  rep
+    .command("fail <run-id>")
+    .description("Fail a V2 RUNNING optimization")
+    .option("--message <msg>", "Error message")
+    .action(async (runId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const result = failOptimization(db, runId, options.message);
+        logger.success(`Failed [${result.status}]`);
+        if (result.errorMessage)
+          logger.log(`  ${chalk.bold("Error:")} ${result.errorMessage}`);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  rep
+    .command("apply-v2 <run-id>")
+    .description("Apply a V2 COMPLETE optimization (COMPLETE → APPLIED)")
+    .action(async (runId) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const result = applyOptimization(db, runId);
+        logger.success(`Applied [${result.status}]`);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  rep
+    .command("set-status <run-id> <status>")
+    .description("Set V2 run status via the state machine")
+    .option("--message <msg>", "Error message (FAILED only)")
+    .option("--json", "Output as JSON")
+    .action(async (runId, status, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const patch = options.message ? { errorMessage: options.message } : {};
+        const result = setRunStatus(db, runId, status, patch);
+        if (options.json) console.log(JSON.stringify(result, null, 2));
+        else logger.success(`Status = ${result.status}`);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  rep
+    .command("stats-v2")
+    .description("V2 aggregated stats")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const stats = getReputationStatsV2();
+        if (options.json) console.log(JSON.stringify(stats, null, 2));
+        else {
+          logger.log(`  ${chalk.bold("Total runs:")}   ${stats.totalRuns}`);
+          logger.log(`  ${chalk.bold("Active:")}       ${stats.activeRuns}`);
+          logger.log(
+            `  ${chalk.bold("Max concurrent:")} ${stats.maxConcurrentOptimizations}`,
+          );
+          logger.log(`  ${chalk.bold("By status:")}`);
+          for (const [k, v] of Object.entries(stats.byStatus))
+            logger.log(`    ${k.padEnd(12)} ${v}`);
+          logger.log(`  ${chalk.bold("By objective:")}`);
+          for (const [k, v] of Object.entries(stats.byObjective))
+            logger.log(`    ${k.padEnd(20)} ${v}`);
+          logger.log(
+            `  ${chalk.bold("Observations:")} ${stats.observations.totalObservations} (${stats.observations.totalDids} DIDs)`,
+          );
+          logger.log(
+            `  ${chalk.bold("Best score ever:")} ${stats.bestScoreEver}`,
+          );
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
 }

package/src/commands/siem.js

@@ -12,6 +12,19 @@ import {
   addTarget,
   exportLogs,
   getSIEMStats,
+  SIEM_FORMAT,
+  SIEM_TARGET_TYPE,
+  SIEM_SEVERITY,
+  SIEM_TARGET_STATUS,
+  SIEM_DEFAULT_BATCH_SIZE,
+  severityToCEF,
+  formatLog,
+  addTargetV2,
+  removeTarget,
+  setTargetStatus,
+  exportLogsV2,
+  getSIEMStatsV2,
+  listTargetsByStatus,
 } from "../lib/siem-exporter.js";
 
 export function registerSiemCommand(program) {
@@ -147,6 +160,239 @@ export function registerSiemCommand(program) {
           }
         }
 
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // ═══════════════════════════════════════════════════════════════
+  // V2 Canonical Subcommands (Phase 51)
+  // ═══════════════════════════════════════════════════════════════
+
+  siem
+    .command("formats")
+    .description("List SIEM export formats (V2)")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(SIEM_FORMAT), null, 2));
+    });
+
+  siem
+    .command("target-types")
+    .description("List SIEM target types (V2)")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(SIEM_TARGET_TYPE), null, 2));
+    });
+
+  siem
+    .command("severities")
+    .description("List SIEM severity levels (V2)")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(SIEM_SEVERITY), null, 2));
+    });
+
+  siem
+    .command("statuses")
+    .description("List SIEM target statuses (V2)")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(SIEM_TARGET_STATUS), null, 2));
+    });
+
+  siem
+    .command("default-batch-size")
+    .description("Show default SIEM batch size (V2)")
+    .action(() => {
+      console.log(JSON.stringify({ batchSize: SIEM_DEFAULT_BATCH_SIZE }));
+    });
+
+  siem
+    .command("severity-cef <severity>")
+    .description("Map a SIEM severity to its CEF integer (0-10)")
+    .action((severity) => {
+      try {
+        console.log(JSON.stringify({ severity, cef: severityToCEF(severity) }));
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  siem
+    .command("format-log <format>")
+    .description("Format a JSON log payload as cef|leef|json")
+    .option("-l, --log <json>", "Log object as JSON", "{}")
+    .action((format, options) => {
+      try {
+        const log = JSON.parse(options.log);
+        const result = formatLog(format, log);
+        console.log(
+          typeof result === "string" ? result : JSON.stringify(result, null, 2),
+        );
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  siem
+    .command("add-target-v2")
+    .description("Add a SIEM target via canonical options (V2)")
+    .option("-t, --type <type>", "Target type")
+    .option("-u, --url <url>", "Target URL")
+    .option("-f, --format <fmt>", "Export format", "json")
+    .option("-c, --config <json>", "Config JSON", "{}")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureSIEMTables(db);
+
+        let config = {};
+        try {
+          config = JSON.parse(options.config);
+        } catch (_err) {
+          logger.error("Invalid --config JSON");
+          process.exit(1);
+        }
+        const target = addTargetV2(db, {
+          type: options.type,
+          url: options.url,
+          format: options.format,
+          config,
+        });
+        console.log(JSON.stringify(target, null, 2));
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  siem
+    .command("remove-target <target-id>")
+    .description("Remove a SIEM target (V2)")
+    .action(async (targetId) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureSIEMTables(db);
+
+        console.log(JSON.stringify(removeTarget(db, targetId), null, 2));
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  siem
+    .command("set-status <target-id> <status>")
+    .description("Transition a SIEM target's status (V2)")
+    .action(async (targetId, status) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureSIEMTables(db);
+
+        console.log(
+          JSON.stringify(setTargetStatus(db, targetId, status), null, 2),
+        );
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  siem
+    .command("export-v2 <target-id>")
+    .description("Batch-export logs to a target (V2)")
+    .option("-l, --logs <json>", "Logs as JSON array", "[]")
+    .option("-b, --batch-size <n>", "Batch size override")
+    .action(async (targetId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureSIEMTables(db);
+
+        let logs = [];
+        try {
+          logs = JSON.parse(options.logs);
+        } catch (_err) {
+          logger.error("Invalid --logs JSON");
+          process.exit(1);
+        }
+        const r = exportLogsV2(db, {
+          targetId,
+          logs,
+          batchSize: options.batchSize ? Number(options.batchSize) : undefined,
+        });
+        console.log(JSON.stringify(r, null, 2));
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  siem
+    .command("stats-v2")
+    .description("Show extended SIEM stats (byFormat/byType/byStatus, V2)")
+    .action(async () => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureSIEMTables(db);
+
+        console.log(JSON.stringify(getSIEMStatsV2(), null, 2));
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  siem
+    .command("by-status <status>")
+    .description("List SIEM targets filtered by status (V2)")
+    .action(async (status) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureSIEMTables(db);
+
+        console.log(JSON.stringify(listTargetsByStatus(status), null, 2));
+
         await shutdown();
       } catch (err) {
         logger.error(`Failed: ${err.message}`);