chainlesschain 0.81.0 → 0.132.0

package/src/commands/encrypt.js

@@ -14,6 +14,35 @@ import {
   getDbEncryptionStatus,
   setDbEncryptionStatus,
   hashPassword,
+  KEY_MATURITY_V2 as CRYPTO_KEY_MATURITY_V2,
+  CRYPTO_JOB_LIFECYCLE_V2,
+  getMaxActiveKeysPerOwnerV2 as cryptoGetMaxActiveKeys,
+  setMaxActiveKeysPerOwnerV2 as cryptoSetMaxActiveKeys,
+  getMaxPendingJobsPerKeyV2 as cryptoGetMaxPendingJobs,
+  setMaxPendingJobsPerKeyV2 as cryptoSetMaxPendingJobs,
+  getKeyIdleMsV2 as cryptoGetKeyIdleMs,
+  setKeyIdleMsV2 as cryptoSetKeyIdleMs,
+  getJobStuckMsV2,
+  setJobStuckMsV2,
+  registerKeyV2 as cryptoRegisterKey,
+  getKeyV2 as cryptoGetKey,
+  listKeysV2 as cryptoListKeys,
+  activateKeyV2 as cryptoActivateKey,
+  rotateKeyV2,
+  retireKeyV2,
+  touchKeyV2 as cryptoTouchKey,
+  createJobV2,
+  getJobV2,
+  listJobsV2,
+  startJobV2,
+  completeJobV2,
+  failJobV2,
+  cancelJobV2,
+  getActiveKeyCountV2 as cryptoGetActiveKeyCount,
+  getPendingJobCountV2,
+  autoRotateIdleKeysV2,
+  autoFailStuckJobsV2,
+  getCryptoManagerStatsV2,
 } from "../lib/crypto-manager.js";
 
 async function promptPassword(message = "Password:") {
@@ -230,4 +259,316 @@ export function registerEncryptCommand(program) {
         process.exit(1);
       }
     });
+
+  // ===== V2 in-memory governance surface (no DB, no bootstrap) =====
+
+  enc
+    .command("key-maturities-v2")
+    .description("[V2] List crypto key maturity states")
+    .option("--json")
+    .action((o) => {
+      const s = Object.values(CRYPTO_KEY_MATURITY_V2);
+      if (o.json) console.log(JSON.stringify(s, null, 2));
+      else for (const v of s) logger.log(v);
+    });
+  enc
+    .command("job-lifecycles-v2")
+    .description("[V2] List crypto job lifecycle states")
+    .option("--json")
+    .action((o) => {
+      const s = Object.values(CRYPTO_JOB_LIFECYCLE_V2);
+      if (o.json) console.log(JSON.stringify(s, null, 2));
+      else for (const v of s) logger.log(v);
+    });
+  enc
+    .command("config-v2")
+    .description("[V2] Show governance config")
+    .option("--json")
+    .action((o) => {
+      const cfg = {
+        maxActiveKeysPerOwner: cryptoGetMaxActiveKeys(),
+        maxPendingJobsPerKey: cryptoGetMaxPendingJobs(),
+        keyIdleMs: cryptoGetKeyIdleMs(),
+        jobStuckMs: getJobStuckMsV2(),
+      };
+      if (o.json) console.log(JSON.stringify(cfg, null, 2));
+      else for (const [k, v] of Object.entries(cfg)) logger.log(`${k}: ${v}`);
+    });
+  enc
+    .command("set-max-active-keys-per-owner-v2 <n>")
+    .description("[V2] Set per-owner active key cap")
+    .action((n) => {
+      try {
+        cryptoSetMaxActiveKeys(Number(n));
+        logger.success(`= ${cryptoGetMaxActiveKeys()}`);
+      } catch (e) {
+        logger.error(e.message);
+        process.exit(1);
+      }
+    });
+  enc
+    .command("set-max-pending-jobs-per-key-v2 <n>")
+    .description("[V2] Set per-key pending job cap")
+    .action((n) => {
+      try {
+        cryptoSetMaxPendingJobs(Number(n));
+        logger.success(`= ${cryptoGetMaxPendingJobs()}`);
+      } catch (e) {
+        logger.error(e.message);
+        process.exit(1);
+      }
+    });
+  enc
+    .command("set-key-idle-ms-v2 <ms>")
+    .description("[V2] Set key idle threshold (ms)")
+    .action((m) => {
+      try {
+        cryptoSetKeyIdleMs(Number(m));
+        logger.success(`= ${cryptoGetKeyIdleMs()}`);
+      } catch (e) {
+        logger.error(e.message);
+        process.exit(1);
+      }
+    });
+  enc
+    .command("set-job-stuck-ms-v2 <ms>")
+    .description("[V2] Set job stuck threshold (ms)")
+    .action((m) => {
+      try {
+        setJobStuckMsV2(Number(m));
+        logger.success(`= ${getJobStuckMsV2()}`);
+      } catch (e) {
+        logger.error(e.message);
+        process.exit(1);
+      }
+    });
+
+  enc
+    .command("register-key-v2 <id>")
+    .description("[V2] Register a crypto key profile (PENDING)")
+    .requiredOption("-o, --owner <id>")
+    .requiredOption("-a, --algorithm <algo>")
+    .option("-p, --purpose <p>", "Purpose", "encryption")
+    .action((id, o) => {
+      try {
+        const k = cryptoRegisterKey(id, {
+          ownerId: o.owner,
+          algorithm: o.algorithm,
+          purpose: o.purpose,
+        });
+        logger.success(`key ${k.id} registered (status=${k.status})`);
+      } catch (e) {
+        logger.error(e.message);
+        process.exit(1);
+      }
+    });
+  enc
+    .command("activate-key-v2 <id>")
+    .description("[V2] Activate key (pending|rotated -> active)")
+    .action((id) => {
+      try {
+        cryptoActivateKey(id);
+        logger.success(`key ${id} active`);
+      } catch (e) {
+        logger.error(e.message);
+        process.exit(1);
+      }
+    });
+  enc
+    .command("rotate-key-v2 <id>")
+    .description("[V2] Rotate key (active -> rotated)")
+    .action((id) => {
+      try {
+        rotateKeyV2(id);
+        logger.success(`key ${id} rotated`);
+      } catch (e) {
+        logger.error(e.message);
+        process.exit(1);
+      }
+    });
+  enc
+    .command("retire-key-v2 <id>")
+    .description("[V2] Retire key (terminal)")
+    .action((id) => {
+      try {
+        retireKeyV2(id);
+        logger.success(`key ${id} retired`);
+      } catch (e) {
+        logger.error(e.message);
+        process.exit(1);
+      }
+    });
+  enc
+    .command("touch-key-v2 <id>")
+    .description("[V2] Bump key lastSeenAt")
+    .action((id) => {
+      try {
+        cryptoTouchKey(id);
+        logger.success(`key ${id} touched`);
+      } catch (e) {
+        logger.error(e.message);
+        process.exit(1);
+      }
+    });
+  enc
+    .command("get-key-v2 <id>")
+    .description("[V2] Show crypto key profile")
+    .option("--json")
+    .action((id) => {
+      const k = cryptoGetKey(id);
+      if (!k) {
+        logger.info("key not found");
+        return;
+      }
+      console.log(JSON.stringify(k, null, 2));
+    });
+  enc
+    .command("list-keys-v2")
+    .description("[V2] List crypto key profiles")
+    .option("-o, --owner <id>")
+    .option("-s, --status <s>")
+    .option("-a, --algorithm <algo>")
+    .option("--json")
+    .action((o) => {
+      const list = cryptoListKeys({
+        ownerId: o.owner,
+        status: o.status,
+        algorithm: o.algorithm,
+      });
+      if (o.json) console.log(JSON.stringify(list, null, 2));
+      else
+        for (const k of list)
+          logger.log(`${k.id}\t${k.ownerId}\t${k.status}\t${k.algorithm}`);
+    });
+
+  enc
+    .command("create-job-v2 <id>")
+    .description("[V2] Create a queued V2 crypto job")
+    .requiredOption("-k, --key <keyId>")
+    .option("-K, --kind <kind>", "Job kind", "encrypt")
+    .action((id, o) => {
+      try {
+        const j = createJobV2(id, { keyId: o.key, kind: o.kind });
+        logger.success(`job ${j.id} queued (key=${j.keyId} kind=${j.kind})`);
+      } catch (e) {
+        logger.error(e.message);
+        process.exit(1);
+      }
+    });
+  enc
+    .command("start-job-v2 <id>")
+    .description("[V2] Start crypto job (queued -> running)")
+    .action((id) => {
+      try {
+        startJobV2(id);
+        logger.success(`job ${id} running`);
+      } catch (e) {
+        logger.error(e.message);
+        process.exit(1);
+      }
+    });
+  enc
+    .command("complete-job-v2 <id>")
+    .description("[V2] Complete crypto job (running -> completed)")
+    .action((id) => {
+      try {
+        completeJobV2(id);
+        logger.success(`job ${id} completed`);
+      } catch (e) {
+        logger.error(e.message);
+        process.exit(1);
+      }
+    });
+  enc
+    .command("fail-job-v2 <id>")
+    .description("[V2] Fail crypto job (running -> failed)")
+    .action((id) => {
+      try {
+        failJobV2(id);
+        logger.success(`job ${id} failed`);
+      } catch (e) {
+        logger.error(e.message);
+        process.exit(1);
+      }
+    });
+  enc
+    .command("cancel-job-v2 <id>")
+    .description("[V2] Cancel crypto job (queued|running -> cancelled)")
+    .action((id) => {
+      try {
+        cancelJobV2(id);
+        logger.success(`job ${id} cancelled`);
+      } catch (e) {
+        logger.error(e.message);
+        process.exit(1);
+      }
+    });
+  enc
+    .command("get-job-v2 <id>")
+    .description("[V2] Show crypto job")
+    .option("--json")
+    .action((id) => {
+      const j = getJobV2(id);
+      if (!j) {
+        logger.info("job not found");
+        return;
+      }
+      console.log(JSON.stringify(j, null, 2));
+    });
+  enc
+    .command("list-jobs-v2")
+    .description("[V2] List V2 crypto jobs")
+    .option("-k, --key <keyId>")
+    .option("-s, --status <s>")
+    .option("-K, --kind <kind>")
+    .option("--json")
+    .action((o) => {
+      const list = listJobsV2({ keyId: o.key, status: o.status, kind: o.kind });
+      if (o.json) console.log(JSON.stringify(list, null, 2));
+      else
+        for (const j of list)
+          logger.log(`${j.id}\t${j.keyId}\t${j.status}\t${j.kind}`);
+    });
+
+  enc
+    .command("active-key-count-v2")
+    .description("[V2] Count active crypto keys (optional --owner)")
+    .option("-o, --owner <id>")
+    .action((o) => logger.log(String(cryptoGetActiveKeyCount(o.owner))));
+  enc
+    .command("pending-job-count-v2")
+    .description("[V2] Count pending crypto jobs (queued+running)")
+    .option("-k, --key <keyId>")
+    .action((o) => logger.log(String(getPendingJobCountV2(o.key))));
+  enc
+    .command("auto-rotate-idle-keys-v2")
+    .description("[V2] Rotate idle active keys")
+    .option("--now <ms>")
+    .option("--json")
+    .action((o) => {
+      const list = autoRotateIdleKeysV2(
+        o.now ? { now: Number(o.now) } : undefined,
+      );
+      if (o.json) console.log(JSON.stringify(list, null, 2));
+      else logger.success(`rotated ${list.length}`);
+    });
+  enc
+    .command("auto-fail-stuck-jobs-v2")
+    .description("[V2] Fail stuck running crypto jobs")
+    .option("--now <ms>")
+    .option("--json")
+    .action((o) => {
+      const list = autoFailStuckJobsV2(
+        o.now ? { now: Number(o.now) } : undefined,
+      );
+      if (o.json) console.log(JSON.stringify(list, null, 2));
+      else logger.success(`failed ${list.length}`);
+    });
+  enc
+    .command("stats-v2")
+    .description("[V2] Show governance stats")
+    .option("--json")
+    .action(() =>
+      console.log(JSON.stringify(getCryptoManagerStatsV2(), null, 2)),
+    );
 }

package/src/commands/export.js

@@ -8,7 +8,41 @@ import ora from "ora";
 import { resolve } from "path";
 import { logger } from "../lib/logger.js";
 import { bootstrap, shutdown } from "../runtime/bootstrap.js";
-import { exportToMarkdown, exportToSite } from "../lib/knowledge-exporter.js";
+import {
+  exportToMarkdown,
+  exportToSite,
+  TARGET_MATURITY_V2,
+  EXPORT_JOB_LIFECYCLE_V2,
+  getMaxActiveTargetsPerOwnerV2,
+  setMaxActiveTargetsPerOwnerV2,
+  getMaxPendingJobsPerTargetV2,
+  setMaxPendingJobsPerTargetV2,
+  getTargetIdleMsV2,
+  setTargetIdleMsV2,
+  getJobStuckMsV2,
+  setJobStuckMsV2,
+  registerTargetV2,
+  getTargetV2,
+  listTargetsV2,
+  setTargetStatusV2,
+  activateTargetV2,
+  pauseTargetV2,
+  archiveTargetV2,
+  touchTargetV2,
+  getActiveTargetCountV2,
+  createExportJobV2,
+  getExportJobV2,
+  listExportJobsV2,
+  setExportJobStatusV2,
+  startExportJobV2,
+  completeExportJobV2,
+  failExportJobV2,
+  cancelExportJobV2,
+  getPendingJobCountV2,
+  autoPauseIdleTargetsV2,
+  autoFailStuckExportJobsV2,
+  getKnowledgeExporterStatsV2,
+} from "../lib/knowledge-exporter.js";
 
 export function registerExportCommand(program) {
   const exp = program
@@ -122,4 +156,225 @@ export function registerExportCommand(program) {
         process.exit(1);
       }
     });
+
+  // ─── 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);
+    }
+  };
+
+  exp
+    .command("target-maturities-v2")
+    .description("List V2 target maturity states")
+    .action(() => out(Object.values(TARGET_MATURITY_V2)));
+
+  exp
+    .command("export-job-lifecycles-v2")
+    .description("List V2 export-job lifecycle states")
+    .action(() => out(Object.values(EXPORT_JOB_LIFECYCLE_V2)));
+
+  exp
+    .command("stats-v2")
+    .description("V2 knowledge-exporter stats")
+    .action(() => out(getKnowledgeExporterStatsV2()));
+
+  exp
+    .command("get-max-active-targets-v2")
+    .description("Get max active targets per owner (V2)")
+    .action(() =>
+      out({ maxActiveTargetsPerOwner: getMaxActiveTargetsPerOwnerV2() }),
+    );
+
+  exp
+    .command("set-max-active-targets-v2 <n>")
+    .description("Set max active targets per owner (V2)")
+    .action((n) =>
+      tryRun(() => {
+        setMaxActiveTargetsPerOwnerV2(Number(n));
+        out({ maxActiveTargetsPerOwner: getMaxActiveTargetsPerOwnerV2() });
+      }),
+    );
+
+  exp
+    .command("get-max-pending-jobs-v2")
+    .description("Get max pending jobs per target (V2)")
+    .action(() =>
+      out({ maxPendingJobsPerTarget: getMaxPendingJobsPerTargetV2() }),
+    );
+
+  exp
+    .command("set-max-pending-jobs-v2 <n>")
+    .description("Set max pending jobs per target (V2)")
+    .action((n) =>
+      tryRun(() => {
+        setMaxPendingJobsPerTargetV2(Number(n));
+        out({ maxPendingJobsPerTarget: getMaxPendingJobsPerTargetV2() });
+      }),
+    );
+
+  exp
+    .command("get-target-idle-ms-v2")
+    .description("Get target idle threshold (V2)")
+    .action(() => out({ targetIdleMs: getTargetIdleMsV2() }));
+
+  exp
+    .command("set-target-idle-ms-v2 <ms>")
+    .description("Set target idle threshold (V2)")
+    .action((ms) =>
+      tryRun(() => {
+        setTargetIdleMsV2(Number(ms));
+        out({ targetIdleMs: getTargetIdleMsV2() });
+      }),
+    );
+
+  exp
+    .command("get-job-stuck-ms-v2")
+    .description("Get export-job stuck threshold (V2)")
+    .action(() => out({ jobStuckMs: getJobStuckMsV2() }));
+
+  exp
+    .command("set-job-stuck-ms-v2 <ms>")
+    .description("Set export-job stuck threshold (V2)")
+    .action((ms) =>
+      tryRun(() => {
+        setJobStuckMsV2(Number(ms));
+        out({ jobStuckMs: getJobStuckMsV2() });
+      }),
+    );
+
+  exp
+    .command("active-target-count-v2 <ownerId>")
+    .description("Active target count for owner (V2)")
+    .action((ownerId) =>
+      out({ ownerId, count: getActiveTargetCountV2(ownerId) }),
+    );
+
+  exp
+    .command("pending-job-count-v2 <targetId>")
+    .description("Pending export-job count for target (V2)")
+    .action((targetId) =>
+      out({ targetId, count: getPendingJobCountV2(targetId) }),
+    );
+
+  exp
+    .command("register-target-v2 <id>")
+    .description("Register a V2 export target")
+    .requiredOption("-o, --owner <id>", "owner id")
+    .requiredOption("-l, --label <label>", "target label")
+    .option("-f, --format <format>", "target format", "markdown")
+    .action((id, opts) =>
+      tryRun(() =>
+        out(
+          registerTargetV2(id, {
+            ownerId: opts.owner,
+            label: opts.label,
+            format: opts.format,
+          }),
+        ),
+      ),
+    );
+
+  exp
+    .command("get-target-v2 <id>")
+    .description("Get a V2 target")
+    .action((id) => out(getTargetV2(id)));
+
+  exp
+    .command("list-targets-v2")
+    .description("List V2 targets")
+    .option("-o, --owner <id>", "filter by owner")
+    .option("-s, --status <status>", "filter by status")
+    .action((opts) =>
+      out(listTargetsV2({ ownerId: opts.owner, status: opts.status })),
+    );
+
+  exp
+    .command("set-target-status-v2 <id> <next>")
+    .description("Set V2 target status")
+    .action((id, next) => tryRun(() => out(setTargetStatusV2(id, next))));
+
+  exp
+    .command("activate-target-v2 <id>")
+    .description("Activate a V2 target")
+    .action((id) => tryRun(() => out(activateTargetV2(id))));
+
+  exp
+    .command("pause-target-v2 <id>")
+    .description("Pause a V2 target")
+    .action((id) => tryRun(() => out(pauseTargetV2(id))));
+
+  exp
+    .command("archive-target-v2 <id>")
+    .description("Archive a V2 target")
+    .action((id) => tryRun(() => out(archiveTargetV2(id))));
+
+  exp
+    .command("touch-target-v2 <id>")
+    .description("Touch a V2 target")
+    .action((id) => tryRun(() => out(touchTargetV2(id))));
+
+  exp
+    .command("create-export-job-v2 <id>")
+    .description("Create a V2 export job")
+    .requiredOption("-t, --target <id>", "target id")
+    .option("-k, --kind <kind>", "job kind", "snapshot")
+    .action((id, opts) =>
+      tryRun(() =>
+        out(createExportJobV2(id, { targetId: opts.target, kind: opts.kind })),
+      ),
+    );
+
+  exp
+    .command("get-export-job-v2 <id>")
+    .description("Get a V2 export job")
+    .action((id) => out(getExportJobV2(id)));
+
+  exp
+    .command("list-export-jobs-v2")
+    .description("List V2 export jobs")
+    .option("-t, --target <id>", "filter by target")
+    .option("-s, --status <status>", "filter by status")
+    .action((opts) =>
+      out(listExportJobsV2({ targetId: opts.target, status: opts.status })),
+    );
+
+  exp
+    .command("set-export-job-status-v2 <id> <next>")
+    .description("Set V2 export-job status")
+    .action((id, next) => tryRun(() => out(setExportJobStatusV2(id, next))));
+
+  exp
+    .command("start-export-job-v2 <id>")
+    .description("Start a V2 export job")
+    .action((id) => tryRun(() => out(startExportJobV2(id))));
+
+  exp
+    .command("complete-export-job-v2 <id>")
+    .description("Complete a V2 export job")
+    .action((id) => tryRun(() => out(completeExportJobV2(id))));
+
+  exp
+    .command("fail-export-job-v2 <id>")
+    .description("Fail a V2 export job")
+    .action((id) => tryRun(() => out(failExportJobV2(id))));
+
+  exp
+    .command("cancel-export-job-v2 <id>")
+    .description("Cancel a V2 export job")
+    .action((id) => tryRun(() => out(cancelExportJobV2(id))));
+
+  exp
+    .command("auto-pause-idle-targets-v2")
+    .description("Auto-pause idle V2 targets")
+    .action(() => out(autoPauseIdleTargetsV2()));
+
+  exp
+    .command("auto-fail-stuck-export-jobs-v2")
+    .description("Auto-fail stuck V2 export jobs")
+    .action(() => out(autoFailStuckExportJobsV2()));
 }