chainlesschain 0.66.0 → 0.132.0

package/src/commands/federation.js

@@ -29,6 +29,28 @@ import {
   listPools,
   destroyPool,
   getFederationHardeningStats,
+  // V2 (Phase 58)
+  NODE_STATUS_V2,
+  FED_DEFAULT_FAILURE_THRESHOLD,
+  FED_DEFAULT_HALF_OPEN_COOLDOWN_MS,
+  FED_DEFAULT_UNHEALTHY_THRESHOLD,
+  FED_DEFAULT_MAX_ACTIVE_NODES,
+  setFailureThreshold,
+  getFailureThreshold,
+  setHalfOpenCooldownMs,
+  getHalfOpenCooldownMs,
+  setUnhealthyThreshold,
+  getUnhealthyThreshold,
+  setMaxActiveNodes,
+  getMaxActiveNodes,
+  getActiveNodeCount,
+  registerNodeV2,
+  getNodeStatusV2,
+  setNodeStatusV2,
+  recordHealthCheckV2,
+  tripCircuit,
+  autoIsolateUnhealthyNodes,
+  getFederationHardeningStatsV2,
 } from "../lib/federation-hardening.js";
 
 function _dbFromCtx(cmd) {
@@ -423,5 +445,266 @@ export function registerFederationCommand(program) {
       );
     });
 
+  /* ── V2 (Phase 58) ──────────────────────────────── */
+
+  fed
+    .command("node-statuses-v2")
+    .description("List V2 node lifecycle statuses")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const statuses = Object.values(NODE_STATUS_V2);
+      if (opts.json) return console.log(JSON.stringify(statuses, null, 2));
+      for (const s of statuses) console.log(`  ${s}`);
+    });
+
+  fed
+    .command("default-failure-threshold")
+    .description("Default circuit-breaker failure threshold")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      if (opts.json)
+        return console.log(JSON.stringify(FED_DEFAULT_FAILURE_THRESHOLD));
+      console.log(FED_DEFAULT_FAILURE_THRESHOLD);
+    });
+
+  fed
+    .command("failure-threshold")
+    .description("Current failure threshold")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const n = getFailureThreshold();
+      if (opts.json) return console.log(JSON.stringify(n));
+      console.log(n);
+    });
+
+  fed
+    .command("set-failure-threshold <n>")
+    .description("Set failure threshold (positive integer)")
+    .option("--json", "JSON output")
+    .action((n, opts) => {
+      setFailureThreshold(Number(n));
+      const out = { failureThreshold: getFailureThreshold() };
+      if (opts.json) return console.log(JSON.stringify(out, null, 2));
+      console.log(`failureThreshold = ${out.failureThreshold}`);
+    });
+
+  fed
+    .command("default-half-open-cooldown-ms")
+    .description("Default half-open cooldown in ms")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      if (opts.json)
+        return console.log(JSON.stringify(FED_DEFAULT_HALF_OPEN_COOLDOWN_MS));
+      console.log(FED_DEFAULT_HALF_OPEN_COOLDOWN_MS);
+    });
+
+  fed
+    .command("half-open-cooldown-ms")
+    .description("Current half-open cooldown in ms")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const n = getHalfOpenCooldownMs();
+      if (opts.json) return console.log(JSON.stringify(n));
+      console.log(n);
+    });
+
+  fed
+    .command("set-half-open-cooldown-ms <ms>")
+    .description("Set half-open cooldown (positive integer ms)")
+    .option("--json", "JSON output")
+    .action((ms, opts) => {
+      setHalfOpenCooldownMs(Number(ms));
+      const out = { halfOpenCooldownMs: getHalfOpenCooldownMs() };
+      if (opts.json) return console.log(JSON.stringify(out, null, 2));
+      console.log(`halfOpenCooldownMs = ${out.halfOpenCooldownMs}`);
+    });
+
+  fed
+    .command("default-unhealthy-threshold")
+    .description("Default consecutive-unhealthy isolation threshold")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      if (opts.json)
+        return console.log(JSON.stringify(FED_DEFAULT_UNHEALTHY_THRESHOLD));
+      console.log(FED_DEFAULT_UNHEALTHY_THRESHOLD);
+    });
+
+  fed
+    .command("unhealthy-threshold")
+    .description("Current consecutive-unhealthy threshold")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const n = getUnhealthyThreshold();
+      if (opts.json) return console.log(JSON.stringify(n));
+      console.log(n);
+    });
+
+  fed
+    .command("set-unhealthy-threshold <n>")
+    .description("Set consecutive-unhealthy threshold")
+    .option("--json", "JSON output")
+    .action((n, opts) => {
+      setUnhealthyThreshold(Number(n));
+      const out = { unhealthyThreshold: getUnhealthyThreshold() };
+      if (opts.json) return console.log(JSON.stringify(out, null, 2));
+      console.log(`unhealthyThreshold = ${out.unhealthyThreshold}`);
+    });
+
+  fed
+    .command("default-max-active-nodes")
+    .description("Default max active nodes cap")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      if (opts.json)
+        return console.log(JSON.stringify(FED_DEFAULT_MAX_ACTIVE_NODES));
+      console.log(FED_DEFAULT_MAX_ACTIVE_NODES);
+    });
+
+  fed
+    .command("max-active-nodes")
+    .description("Current max active nodes cap")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const n = getMaxActiveNodes();
+      if (opts.json) return console.log(JSON.stringify(n));
+      console.log(n);
+    });
+
+  fed
+    .command("active-node-count")
+    .description("Number of currently ACTIVE nodes")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const n = getActiveNodeCount();
+      if (opts.json) return console.log(JSON.stringify(n));
+      console.log(n);
+    });
+
+  fed
+    .command("set-max-active-nodes <n>")
+    .description("Set max active nodes cap")
+    .option("--json", "JSON output")
+    .action((n, opts) => {
+      setMaxActiveNodes(Number(n));
+      const out = { maxActiveNodes: getMaxActiveNodes() };
+      if (opts.json) return console.log(JSON.stringify(out, null, 2));
+      console.log(`maxActiveNodes = ${out.maxActiveNodes}`);
+    });
+
+  fed
+    .command("register-v2 <node-id>")
+    .description("Register a node with V2 lifecycle tracking")
+    .option("-m, --metadata <json>", "JSON metadata")
+    .option("--json", "JSON output")
+    .action((nodeId, opts) => {
+      const db = _dbFromCtx(fed);
+      const metadata = opts.metadata ? JSON.parse(opts.metadata) : undefined;
+      const r = registerNodeV2(db, { nodeId, metadata });
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      console.log(`Registered ${nodeId} (status: ${r.status})`);
+    });
+
+  fed
+    .command("node-status-v2 <node-id>")
+    .description("Get V2 node status")
+    .option("--json", "JSON output")
+    .action((nodeId, opts) => {
+      const r = getNodeStatusV2(nodeId);
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      if (!r) return console.log("(not found)");
+      console.log(`${nodeId}: ${r.status}${r.reason ? ` — ${r.reason}` : ""}`);
+    });
+
+  fed
+    .command("set-node-status-v2 <node-id> <status>")
+    .description("Transition node to a new status")
+    .option("-r, --reason <reason>")
+    .option("-m, --metadata <json>")
+    .option("--json", "JSON output")
+    .action((nodeId, status, opts) => {
+      const db = _dbFromCtx(fed);
+      const patch = {};
+      if (opts.reason !== undefined) patch.reason = opts.reason;
+      if (opts.metadata !== undefined)
+        patch.metadata = JSON.parse(opts.metadata);
+      const r = setNodeStatusV2(db, nodeId, status, patch);
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      console.log(`${nodeId} → ${r.status}`);
+    });
+
+  fed
+    .command("record-health-v2 <node-id>")
+    .description("Record a V2 health check (throws on invalid input)")
+    .option(
+      "-t, --type <checkType>",
+      "heartbeat|latency|success_rate|cpu_usage|memory_usage",
+      "heartbeat",
+    )
+    .option(
+      "-s, --status <status>",
+      "healthy|degraded|unhealthy|unknown",
+      "healthy",
+    )
+    .option("-m, --metrics <json>", "Optional metrics JSON")
+    .option("--json", "JSON output")
+    .action((nodeId, opts) => {
+      const db = _dbFromCtx(fed);
+      const metrics = opts.metrics ? JSON.parse(opts.metrics) : undefined;
+      const r = recordHealthCheckV2(db, {
+        nodeId,
+        checkType: opts.type,
+        status: opts.status,
+        metrics,
+      });
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      console.log(`recorded check ${r.checkId}`);
+    });
+
+  fed
+    .command("trip-circuit <node-id>")
+    .description("Force-trip a circuit breaker (closed/half_open → open)")
+    .option("--json", "JSON output")
+    .action((nodeId, opts) => {
+      const db = _dbFromCtx(fed);
+      const r = tripCircuit(db, nodeId);
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      console.log(`${nodeId} circuit → ${r.state}`);
+    });
+
+  fed
+    .command("auto-isolate-unhealthy")
+    .description(
+      "Bulk-isolate ACTIVE nodes with N consecutive UNHEALTHY checks",
+    )
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const db = _dbFromCtx(fed);
+      const r = autoIsolateUnhealthyNodes(db);
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      console.log(`Isolated ${r.length} node(s)`);
+      for (const n of r) console.log(`  ${n.node_id}`);
+    });
+
+  fed
+    .command("stats-v2")
+    .description("V2 federation hardening statistics")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const db = _dbFromCtx(fed);
+      const s = getFederationHardeningStatsV2(db);
+      if (opts.json) return console.log(JSON.stringify(s, null, 2));
+      console.log(
+        `Nodes: ${s.totalNodes} (active=${s.activeNodes}, isolated=${s.isolatedNodes})`,
+      );
+      console.log(`Circuits: ${s.totalCircuits}`);
+      for (const [state, count] of Object.entries(s.circuitsByState)) {
+        if (count > 0) console.log(`  ${state.padEnd(10)} ${count}`);
+      }
+      console.log(`Health checks: ${s.totalHealthChecks}`);
+      console.log(
+        `config: failureThreshold=${s.failureThreshold} halfOpenCooldownMs=${s.halfOpenCooldownMs} unhealthyThreshold=${s.unhealthyThreshold} maxActiveNodes=${s.maxActiveNodes}`,
+      );
+    });
+
   program.addCommand(fed);
 }

package/src/commands/fusion.js

@@ -24,8 +24,49 @@ import {
   detectLanguage,
   getTranslationStats,
   getProtocolFusionStats,
+  BRIDGE_MATURITY_V2,
+  TRANSLATION_RUN_V2,
+  getMaxActiveBridgesPerOperator,
+  setMaxActiveBridgesPerOperator,
+  getMaxRunningTranslationsPerBridge,
+  setMaxRunningTranslationsPerBridge,
+  getBridgeIdleMs,
+  setBridgeIdleMs,
+  getTranslationStuckMs,
+  setTranslationStuckMs,
+  getActiveBridgeCount,
+  getRunningTranslationCount,
+  registerBridgeV2,
+  getBridgeV2,
+  listBridgesV2,
+  setBridgeMaturityV2,
+  activateBridge,
+  degradeBridge,
+  deprecateBridge,
+  retireBridge,
+  touchBridgeUsage,
+  enqueueTranslationV2,
+  getTranslationV2,
+  listTranslationsV2,
+  setTranslationStatusV2,
+  startTranslation,
+  succeedTranslation,
+  failTranslation,
+  cancelTranslation,
+  autoRetireIdleBridges,
+  autoFailStuckRunningTranslations,
+  getProtocolFusionStatsV2,
 } from "../lib/protocol-fusion.js";
 
+function _parseJson(s) {
+  if (!s) return undefined;
+  try {
+    return JSON.parse(s);
+  } catch {
+    throw new Error(`invalid JSON: ${s}`);
+  }
+}
+
 function _dbFromCtx(cmd) {
   const root = cmd?.parent?.parent ?? cmd?.parent;
   return root?._db;
@@ -328,5 +369,222 @@ export function registerFusionCommand(program) {
       );
     });
 
+  /* ── V2 Surface (Phase 72-73) ─────────────────────────── */
+
+  fu.command("bridge-maturities-v2")
+    .description("List BRIDGE_MATURITY_V2 enum values")
+    .action(() => {
+      for (const v of Object.values(BRIDGE_MATURITY_V2)) console.log(`  ${v}`);
+    });
+
+  fu.command("translation-runs-v2")
+    .description("List TRANSLATION_RUN_V2 enum values")
+    .action(() => {
+      for (const v of Object.values(TRANSLATION_RUN_V2)) console.log(`  ${v}`);
+    });
+
+  fu.command("max-active-bridges-per-operator")
+    .description("Get current max-active-bridges-per-operator cap")
+    .action(() => console.log(getMaxActiveBridgesPerOperator()));
+  fu.command("set-max-active-bridges-per-operator <n>")
+    .description("Set max-active-bridges-per-operator cap")
+    .action((n) => console.log(setMaxActiveBridgesPerOperator(Number(n))));
+
+  fu.command("max-running-translations-per-bridge")
+    .description("Get current max-running-translations-per-bridge cap")
+    .action(() => console.log(getMaxRunningTranslationsPerBridge()));
+  fu.command("set-max-running-translations-per-bridge <n>")
+    .description("Set max-running-translations-per-bridge cap")
+    .action((n) => console.log(setMaxRunningTranslationsPerBridge(Number(n))));
+
+  fu.command("bridge-idle-ms")
+    .description("Get current bridge-idle-ms threshold")
+    .action(() => console.log(getBridgeIdleMs()));
+  fu.command("set-bridge-idle-ms <n>")
+    .description("Set bridge-idle-ms threshold")
+    .action((n) => console.log(setBridgeIdleMs(Number(n))));
+
+  fu.command("translation-stuck-ms")
+    .description("Get current translation-stuck-ms threshold")
+    .action(() => console.log(getTranslationStuckMs()));
+  fu.command("set-translation-stuck-ms <n>")
+    .description("Set translation-stuck-ms threshold")
+    .action((n) => console.log(setTranslationStuckMs(Number(n))));
+
+  fu.command("active-bridge-count")
+    .description(
+      "Count non-retired, non-provisional bridges (optionally by operator)",
+    )
+    .option("-o, --operator <operator>", "scope to operator")
+    .action((opts) => console.log(getActiveBridgeCount(opts.operator)));
+
+  fu.command("running-translation-count")
+    .description("Count RUNNING translations (optionally by bridge)")
+    .option("-b, --bridge <bridge>", "scope to bridge")
+    .action((opts) => console.log(getRunningTranslationCount(opts.bridge)));
+
+  fu.command("register-bridge-v2 <bridge-id>")
+    .description("Register V2 bridge (provisional by default)")
+    .requiredOption("-o, --operator <operator>", "operator id")
+    .requiredOption("-s, --source <protocol>", "source protocol")
+    .requiredOption("-t, --target <protocol>", "target protocol")
+    .option(
+      "-i, --initial <status>",
+      "initial status",
+      BRIDGE_MATURITY_V2.PROVISIONAL,
+    )
+    .option("--metadata <json>", "metadata JSON")
+    .action((id, opts) => {
+      const b = registerBridgeV2({
+        id,
+        operator: opts.operator,
+        sourceProtocol: opts.source,
+        targetProtocol: opts.target,
+        initialStatus: opts.initial,
+        metadata: _parseJson(opts.metadata),
+      });
+      console.log(JSON.stringify(b, null, 2));
+    });
+
+  fu.command("bridge-v2 <bridge-id>")
+    .description("Show V2 bridge state")
+    .action((id) => {
+      const b = getBridgeV2(id);
+      if (!b) return console.error(`bridge ${id} not found`);
+      console.log(JSON.stringify(b, null, 2));
+    });
+
+  fu.command("list-bridges-v2")
+    .description("List V2 bridges")
+    .option("-o, --operator <operator>", "filter by operator")
+    .option("-s, --status <status>", "filter by status")
+    .action((opts) => {
+      console.log(JSON.stringify(listBridgesV2(opts), null, 2));
+    });
+
+  fu.command("set-bridge-maturity-v2 <bridge-id> <status>")
+    .description("Transition V2 bridge maturity")
+    .option("-r, --reason <reason>", "transition reason")
+    .option("--metadata <json>", "metadata patch JSON")
+    .action((id, status, opts) => {
+      const b = setBridgeMaturityV2(id, status, {
+        reason: opts.reason,
+        metadata: _parseJson(opts.metadata),
+      });
+      console.log(JSON.stringify(b, null, 2));
+    });
+
+  for (const [name, fn] of [
+    ["activate-bridge", activateBridge],
+    ["degrade-bridge", degradeBridge],
+    ["deprecate-bridge", deprecateBridge],
+    ["retire-bridge", retireBridge],
+  ]) {
+    fu.command(`${name} <bridge-id>`)
+      .description(`Shortcut for ${name.replace("-bridge", "")} transition`)
+      .option("-r, --reason <reason>", "transition reason")
+      .action((id, opts) => {
+        const b = fn(id, { reason: opts.reason });
+        console.log(JSON.stringify(b, null, 2));
+      });
+  }
+
+  fu.command("touch-bridge-usage <bridge-id>")
+    .description("Mark V2 bridge as used now (for idle auto-retire)")
+    .action((id) => {
+      const b = touchBridgeUsage(id);
+      console.log(JSON.stringify(b, null, 2));
+    });
+
+  fu.command("enqueue-translation-v2 <translation-id>")
+    .description("Enqueue a V2 translation run")
+    .requiredOption("-b, --bridge <bridge>", "bridge id")
+    .requiredOption("-t, --target <lang>", "target language")
+    .requiredOption("-x, --text <text>", "text to translate")
+    .option("-s, --source <lang>", "source language", "auto")
+    .option("--metadata <json>", "metadata JSON")
+    .action((id, opts) => {
+      const t = enqueueTranslationV2({
+        id,
+        bridgeId: opts.bridge,
+        targetLang: opts.target,
+        text: opts.text,
+        sourceLang: opts.source,
+        metadata: _parseJson(opts.metadata),
+      });
+      console.log(JSON.stringify(t, null, 2));
+    });
+
+  fu.command("translation-v2 <translation-id>")
+    .description("Show V2 translation state")
+    .action((id) => {
+      const t = getTranslationV2(id);
+      if (!t) return console.error(`translation ${id} not found`);
+      console.log(JSON.stringify(t, null, 2));
+    });
+
+  fu.command("list-translations-v2")
+    .description("List V2 translations")
+    .option("-b, --bridge <bridge>", "filter by bridge")
+    .option("-s, --status <status>", "filter by status")
+    .action((opts) => {
+      console.log(JSON.stringify(listTranslationsV2(opts), null, 2));
+    });
+
+  fu.command("set-translation-status-v2 <translation-id> <status>")
+    .description("Transition V2 translation status")
+    .option("-r, --reason <reason>", "transition reason")
+    .option("--metadata <json>", "metadata patch JSON")
+    .option("--result <json>", "result JSON (on success)")
+    .action((id, status, opts) => {
+      const t = setTranslationStatusV2(id, status, {
+        reason: opts.reason,
+        metadata: _parseJson(opts.metadata),
+        result: _parseJson(opts.result),
+      });
+      console.log(JSON.stringify(t, null, 2));
+    });
+
+  for (const [name, fn] of [
+    ["start-translation", startTranslation],
+    ["succeed-translation", succeedTranslation],
+    ["fail-translation", failTranslation],
+    ["cancel-translation", cancelTranslation],
+  ]) {
+    fu.command(`${name} <translation-id>`)
+      .description(
+        `Shortcut for ${name.replace("-translation", "")} transition`,
+      )
+      .option("-r, --reason <reason>", "transition reason")
+      .action((id, opts) => {
+        const t = fn(id, { reason: opts.reason });
+        console.log(JSON.stringify(t, null, 2));
+      });
+  }
+
+  fu.command("auto-retire-idle-bridges")
+    .description(
+      "Bulk-retire ACTIVE/DEGRADED/DEPRECATED bridges whose lastUsedAt is older than bridgeIdleMs",
+    )
+    .action(() => {
+      const flipped = autoRetireIdleBridges();
+      console.log(JSON.stringify({ flipped }, null, 2));
+    });
+
+  fu.command("auto-fail-stuck-running-translations")
+    .description(
+      "Bulk-fail RUNNING translations whose startedAt is older than translationStuckMs",
+    )
+    .action(() => {
+      const flipped = autoFailStuckRunningTranslations();
+      console.log(JSON.stringify({ flipped }, null, 2));
+    });
+
+  fu.command("stats-v2")
+    .description("Show V2 stats with all-enum zero-initialized counters")
+    .action(() => {
+      console.log(JSON.stringify(getProtocolFusionStatsV2(), null, 2));
+    });
+
   program.addCommand(fu);
 }