chainlesschain 0.66.0 → 0.132.0

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

package/src/commands/skill.js

@@ -11,7 +11,41 @@ import ora from "ora";
 import fs from "fs";
 import path from "path";
 import { logger } from "../lib/logger.js";
-import { CLISkillLoader, LAYER_NAMES } from "../lib/skill-loader.js";
+import {
+  CLISkillLoader,
+  LAYER_NAMES,
+  SKILL_MATURITY_V2,
+  EXECUTION_LIFECYCLE_V2,
+  getMaxActiveSkillsPerOwnerV2,
+  setMaxActiveSkillsPerOwnerV2,
+  getMaxPendingExecutionsPerSkillV2,
+  setMaxPendingExecutionsPerSkillV2,
+  getSkillIdleMsV2,
+  setSkillIdleMsV2,
+  getExecStuckMsV2,
+  setExecStuckMsV2,
+  registerSkillV2,
+  getSkillV2,
+  listSkillsV2,
+  setSkillStatusV2,
+  activateSkillV2,
+  deprecateSkillV2,
+  archiveSkillV2,
+  touchSkillV2,
+  getActiveSkillCountV2,
+  createExecutionV2,
+  getExecutionV2,
+  listExecutionsV2,
+  setExecutionStatusV2,
+  startExecutionV2,
+  succeedExecutionV2,
+  failExecutionV2,
+  cancelExecutionV2,
+  getPendingExecutionCountV2,
+  autoDeprecateIdleSkillsV2,
+  autoFailStuckExecutionsV2,
+  getSkillLoaderStatsV2,
+} from "../lib/skill-loader.js";
 import { getElectronUserDataDir } from "../lib/paths.js";
 import { findProjectRoot } from "../lib/project-detector.js";
 import {
@@ -695,4 +729,236 @@ export function registerSkillCommand(program) {
         `  ${chalk.bold("Total:")} ${allSkills.length} skills resolved\n`,
       );
     });
+
+  // ─── V2 Governance Layer ──────────────────────────────────────────
+  const out = (obj) => console.log(JSON.stringify(obj, null, 2));
+  const tryRun = (fn) => {
+    try {
+      fn();
+    } catch (err) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+  };
+
+  skill
+    .command("skill-maturities-v2")
+    .description("List V2 skill maturity states")
+    .action(() => out(Object.values(SKILL_MATURITY_V2)));
+
+  skill
+    .command("execution-lifecycles-v2")
+    .description("List V2 execution lifecycle states")
+    .action(() => out(Object.values(EXECUTION_LIFECYCLE_V2)));
+
+  skill
+    .command("stats-v2")
+    .description("V2 skill-loader stats")
+    .action(() => out(getSkillLoaderStatsV2()));
+
+  skill
+    .command("get-max-active-skills-v2")
+    .description("Get max active skills per owner (V2)")
+    .action(() =>
+      out({ maxActiveSkillsPerOwner: getMaxActiveSkillsPerOwnerV2() }),
+    );
+
+  skill
+    .command("set-max-active-skills-v2 <n>")
+    .description("Set max active skills per owner (V2)")
+    .action((n) =>
+      tryRun(() => {
+        setMaxActiveSkillsPerOwnerV2(Number(n));
+        out({ maxActiveSkillsPerOwner: getMaxActiveSkillsPerOwnerV2() });
+      }),
+    );
+
+  skill
+    .command("get-max-pending-executions-v2")
+    .description("Get max pending executions per skill (V2)")
+    .action(() =>
+      out({
+        maxPendingExecutionsPerSkill: getMaxPendingExecutionsPerSkillV2(),
+      }),
+    );
+
+  skill
+    .command("set-max-pending-executions-v2 <n>")
+    .description("Set max pending executions per skill (V2)")
+    .action((n) =>
+      tryRun(() => {
+        setMaxPendingExecutionsPerSkillV2(Number(n));
+        out({
+          maxPendingExecutionsPerSkill: getMaxPendingExecutionsPerSkillV2(),
+        });
+      }),
+    );
+
+  skill
+    .command("get-skill-idle-ms-v2")
+    .description("Get skill idle threshold (V2)")
+    .action(() => out({ skillIdleMs: getSkillIdleMsV2() }));
+
+  skill
+    .command("set-skill-idle-ms-v2 <ms>")
+    .description("Set skill idle threshold (V2)")
+    .action((ms) =>
+      tryRun(() => {
+        setSkillIdleMsV2(Number(ms));
+        out({ skillIdleMs: getSkillIdleMsV2() });
+      }),
+    );
+
+  skill
+    .command("get-exec-stuck-ms-v2")
+    .description("Get execution stuck threshold (V2)")
+    .action(() => out({ execStuckMs: getExecStuckMsV2() }));
+
+  skill
+    .command("set-exec-stuck-ms-v2 <ms>")
+    .description("Set execution stuck threshold (V2)")
+    .action((ms) =>
+      tryRun(() => {
+        setExecStuckMsV2(Number(ms));
+        out({ execStuckMs: getExecStuckMsV2() });
+      }),
+    );
+
+  skill
+    .command("active-skill-count-v2 <ownerId>")
+    .description("Active skill count for owner (V2)")
+    .action((ownerId) =>
+      out({ ownerId, count: getActiveSkillCountV2(ownerId) }),
+    );
+
+  skill
+    .command("pending-execution-count-v2 <skillId>")
+    .description("Pending execution count for skill (V2)")
+    .action((skillId) =>
+      out({ skillId, count: getPendingExecutionCountV2(skillId) }),
+    );
+
+  skill
+    .command("register-skill-v2 <id>")
+    .description("Register a V2 skill")
+    .requiredOption("-o, --owner <id>", "owner id")
+    .requiredOption("-n, --name <name>", "skill name")
+    .option("-l, --layer <layer>", "skill layer", "workspace")
+    .action((id, opts) =>
+      tryRun(() =>
+        out(
+          registerSkillV2(id, {
+            ownerId: opts.owner,
+            name: opts.name,
+            layer: opts.layer,
+          }),
+        ),
+      ),
+    );
+
+  skill
+    .command("get-skill-v2 <id>")
+    .description("Get a V2 skill")
+    .action((id) => out(getSkillV2(id)));
+
+  skill
+    .command("list-skills-v2")
+    .description("List V2 skills")
+    .option("-o, --owner <id>", "filter by owner")
+    .option("-s, --status <status>", "filter by status")
+    .option("-l, --layer <layer>", "filter by layer")
+    .action((opts) =>
+      out(
+        listSkillsV2({
+          ownerId: opts.owner,
+          status: opts.status,
+          layer: opts.layer,
+        }),
+      ),
+    );
+
+  skill
+    .command("set-skill-status-v2 <id> <next>")
+    .description("Set V2 skill status")
+    .action((id, next) => tryRun(() => out(setSkillStatusV2(id, next))));
+
+  skill
+    .command("activate-skill-v2 <id>")
+    .description("Activate a V2 skill")
+    .action((id) => tryRun(() => out(activateSkillV2(id))));
+
+  skill
+    .command("deprecate-skill-v2 <id>")
+    .description("Deprecate a V2 skill")
+    .action((id) => tryRun(() => out(deprecateSkillV2(id))));
+
+  skill
+    .command("archive-skill-v2 <id>")
+    .description("Archive a V2 skill")
+    .action((id) => tryRun(() => out(archiveSkillV2(id))));
+
+  skill
+    .command("touch-skill-v2 <id>")
+    .description("Touch a V2 skill")
+    .action((id) => tryRun(() => out(touchSkillV2(id))));
+
+  skill
+    .command("create-execution-v2 <id>")
+    .description("Create a V2 execution")
+    .requiredOption("-s, --skill <id>", "skill id")
+    .option("-k, --kind <kind>", "execution kind", "invoke")
+    .action((id, opts) =>
+      tryRun(() =>
+        out(createExecutionV2(id, { skillId: opts.skill, kind: opts.kind })),
+      ),
+    );
+
+  skill
+    .command("get-execution-v2 <id>")
+    .description("Get a V2 execution")
+    .action((id) => out(getExecutionV2(id)));
+
+  skill
+    .command("list-executions-v2")
+    .description("List V2 executions")
+    .option("-s, --skill <id>", "filter by skill")
+    .option("-t, --status <status>", "filter by status")
+    .action((opts) =>
+      out(listExecutionsV2({ skillId: opts.skill, status: opts.status })),
+    );
+
+  skill
+    .command("set-execution-status-v2 <id> <next>")
+    .description("Set V2 execution status")
+    .action((id, next) => tryRun(() => out(setExecutionStatusV2(id, next))));
+
+  skill
+    .command("start-execution-v2 <id>")
+    .description("Start a V2 execution")
+    .action((id) => tryRun(() => out(startExecutionV2(id))));
+
+  skill
+    .command("succeed-execution-v2 <id>")
+    .description("Succeed a V2 execution")
+    .action((id) => tryRun(() => out(succeedExecutionV2(id))));
+
+  skill
+    .command("fail-execution-v2 <id>")
+    .description("Fail a V2 execution")
+    .action((id) => tryRun(() => out(failExecutionV2(id))));
+
+  skill
+    .command("cancel-execution-v2 <id>")
+    .description("Cancel a V2 execution")
+    .action((id) => tryRun(() => out(cancelExecutionV2(id))));
+
+  skill
+    .command("auto-deprecate-idle-skills-v2")
+    .description("Auto-deprecate idle V2 skills")
+    .action(() => out(autoDeprecateIdleSkillsV2()));
+
+  skill
+    .command("auto-fail-stuck-executions-v2")
+    .description("Auto-fail stuck V2 executions")
+    .action(() => out(autoFailStuckExecutionsV2()));
 }