chainlesschain 0.66.0 → 0.132.0

package/src/commands/p2p.js

@@ -20,6 +20,35 @@ import {
   unpairDevice,
   generatePeerId,
   P2PBridge,
+  PEER_MATURITY_V2,
+  MESSAGE_LIFECYCLE_V2,
+  getMaxActivePeersPerNetworkV2,
+  setMaxActivePeersPerNetworkV2,
+  getMaxPendingMessagesPerPeerV2,
+  setMaxPendingMessagesPerPeerV2,
+  getPeerIdleMsV2,
+  setPeerIdleMsV2,
+  getMessageStuckMsV2,
+  setMessageStuckMsV2,
+  registerPeerV2,
+  getPeerV2,
+  listPeersV2,
+  activatePeerV2,
+  offlinePeerV2,
+  archivePeerV2,
+  touchPeerV2,
+  createMessageV2,
+  getMessageV2,
+  listMessagesV2,
+  startMessageV2,
+  deliverMessageV2,
+  failMessageV2,
+  cancelMessageV2,
+  getActivePeerCountV2,
+  getPendingMessageCountV2,
+  autoOfflineIdlePeersV2,
+  autoFailStuckMessagesV2,
+  getP2pManagerStatsV2,
 } from "../lib/p2p-manager.js";
 
 export function registerP2pCommand(program) {
@@ -271,4 +300,365 @@ export function registerP2pCommand(program) {
         process.exit(1);
       }
     });
+
+  // ===== V2 in-memory governance surface (no DB, no bootstrap) =====
+
+  p2p
+    .command("peer-maturities-v2")
+    .description("[V2] List peer maturity states")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const states = Object.values(PEER_MATURITY_V2);
+      if (options.json) console.log(JSON.stringify(states, null, 2));
+      else for (const s of states) logger.log(s);
+    });
+
+  p2p
+    .command("message-lifecycles-v2")
+    .description("[V2] List message lifecycle states")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const states = Object.values(MESSAGE_LIFECYCLE_V2);
+      if (options.json) console.log(JSON.stringify(states, null, 2));
+      else for (const s of states) logger.log(s);
+    });
+
+  p2p
+    .command("config-v2")
+    .description("[V2] Show governance config")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const cfg = {
+        maxActivePeersPerNetwork: getMaxActivePeersPerNetworkV2(),
+        maxPendingMessagesPerPeer: getMaxPendingMessagesPerPeerV2(),
+        peerIdleMs: getPeerIdleMsV2(),
+        messageStuckMs: getMessageStuckMsV2(),
+      };
+      if (options.json) console.log(JSON.stringify(cfg, null, 2));
+      else for (const [k, v] of Object.entries(cfg)) logger.log(`${k}: ${v}`);
+    });
+
+  p2p
+    .command("set-max-active-peers-per-network-v2 <n>")
+    .description("[V2] Set per-network active peer cap")
+    .action((n) => {
+      try {
+        setMaxActivePeersPerNetworkV2(Number(n));
+        logger.success(
+          `max active peers/network = ${getMaxActivePeersPerNetworkV2()}`,
+        );
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("set-max-pending-messages-per-peer-v2 <n>")
+    .description("[V2] Set per-peer pending message cap")
+    .action((n) => {
+      try {
+        setMaxPendingMessagesPerPeerV2(Number(n));
+        logger.success(
+          `max pending messages/peer = ${getMaxPendingMessagesPerPeerV2()}`,
+        );
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("set-peer-idle-ms-v2 <ms>")
+    .description("[V2] Set peer idle threshold (ms)")
+    .action((ms) => {
+      try {
+        setPeerIdleMsV2(Number(ms));
+        logger.success(`peer idle ms = ${getPeerIdleMsV2()}`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("set-message-stuck-ms-v2 <ms>")
+    .description("[V2] Set message stuck threshold (ms)")
+    .action((ms) => {
+      try {
+        setMessageStuckMsV2(Number(ms));
+        logger.success(`message stuck ms = ${getMessageStuckMsV2()}`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("register-peer-v2 <id>")
+    .description("[V2] Register a peer profile (PENDING)")
+    .requiredOption("-n, --network <id>", "Network ID")
+    .option("-d, --device-name <name>", "Device name")
+    .option("-t, --device-type <type>", "Device type", "desktop")
+    .action((id, opts) => {
+      try {
+        const peer = registerPeerV2(id, {
+          networkId: opts.network,
+          deviceName: opts.deviceName,
+          deviceType: opts.deviceType,
+        });
+        logger.success(`peer ${peer.id} registered (status=${peer.status})`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("activate-peer-v2 <id>")
+    .description("[V2] Activate a peer (pending|offline -> active)")
+    .action((id) => {
+      try {
+        const p = activatePeerV2(id);
+        logger.success(`peer ${p.id} active`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("offline-peer-v2 <id>")
+    .description("[V2] Mark peer offline (active -> offline)")
+    .action((id) => {
+      try {
+        const p = offlinePeerV2(id);
+        logger.success(`peer ${p.id} offline`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("archive-peer-v2 <id>")
+    .description("[V2] Archive peer (terminal)")
+    .action((id) => {
+      try {
+        const p = archivePeerV2(id);
+        logger.success(`peer ${p.id} archived`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("touch-peer-v2 <id>")
+    .description("[V2] Bump peer lastSeenAt")
+    .action((id) => {
+      try {
+        const p = touchPeerV2(id);
+        logger.success(`peer ${p.id} touched`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("get-peer-v2 <id>")
+    .description("[V2] Show peer profile")
+    .option("--json", "Output as JSON")
+    .action((id, opts) => {
+      try {
+        const p = getPeerV2(id);
+        if (!p) {
+          logger.info("peer not found");
+          return;
+        }
+        if (opts.json) console.log(JSON.stringify(p, null, 2));
+        else logger.log(JSON.stringify(p, null, 2));
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("list-peers-v2")
+    .description("[V2] List peer profiles")
+    .option("-n, --network <id>", "Filter by network")
+    .option("-s, --status <s>", "Filter by status")
+    .option("-t, --device-type <t>", "Filter by device type")
+    .option("--json", "Output as JSON")
+    .action((opts) => {
+      const list = listPeersV2({
+        networkId: opts.network,
+        status: opts.status,
+        deviceType: opts.deviceType,
+      });
+      if (opts.json) console.log(JSON.stringify(list, null, 2));
+      else
+        for (const p of list)
+          logger.log(`${p.id}\t${p.networkId}\t${p.status}\t${p.deviceType}`);
+    });
+
+  p2p
+    .command("create-message-v2 <id>")
+    .description("[V2] Create a queued V2 message")
+    .requiredOption("-p, --peer <peerId>", "Peer ID")
+    .option("-k, --kind <kind>", "Message kind", "text")
+    .action((id, opts) => {
+      try {
+        const m = createMessageV2(id, { peerId: opts.peer, kind: opts.kind });
+        logger.success(
+          `message ${m.id} queued (peer=${m.peerId} kind=${m.kind})`,
+        );
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("start-message-v2 <id>")
+    .description("[V2] Mark message sending (queued -> sending)")
+    .action((id) => {
+      try {
+        const m = startMessageV2(id);
+        logger.success(`message ${m.id} sending`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("deliver-message-v2 <id>")
+    .description("[V2] Mark message delivered (sending -> delivered)")
+    .action((id) => {
+      try {
+        const m = deliverMessageV2(id);
+        logger.success(`message ${m.id} delivered`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("fail-message-v2 <id>")
+    .description("[V2] Mark message failed (queued|sending -> failed)")
+    .action((id) => {
+      try {
+        const m = failMessageV2(id);
+        logger.success(`message ${m.id} failed`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("cancel-message-v2 <id>")
+    .description("[V2] Cancel message (queued|sending -> cancelled)")
+    .action((id) => {
+      try {
+        const m = cancelMessageV2(id);
+        logger.success(`message ${m.id} cancelled`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("get-message-v2 <id>")
+    .description("[V2] Show message")
+    .option("--json", "Output as JSON")
+    .action((id, opts) => {
+      try {
+        const m = getMessageV2(id);
+        if (!m) {
+          logger.info("message not found");
+          return;
+        }
+        if (opts.json) console.log(JSON.stringify(m, null, 2));
+        else logger.log(JSON.stringify(m, null, 2));
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("list-messages-v2")
+    .description("[V2] List V2 messages")
+    .option("-p, --peer <peerId>", "Filter by peer")
+    .option("-s, --status <s>", "Filter by status")
+    .option("--json", "Output as JSON")
+    .action((opts) => {
+      const list = listMessagesV2({ peerId: opts.peer, status: opts.status });
+      if (opts.json) console.log(JSON.stringify(list, null, 2));
+      else
+        for (const m of list)
+          logger.log(`${m.id}\t${m.peerId}\t${m.status}\t${m.kind}`);
+    });
+
+  p2p
+    .command("active-peer-count-v2")
+    .description("[V2] Count active peers (optional --network filter)")
+    .option("-n, --network <id>", "Filter by network")
+    .action((opts) => {
+      const n = getActivePeerCountV2(opts.network);
+      logger.log(String(n));
+    });
+
+  p2p
+    .command("pending-message-count-v2")
+    .description(
+      "[V2] Count pending messages (queued+sending) (optional --peer filter)",
+    )
+    .option("-p, --peer <peerId>", "Filter by peer")
+    .action((opts) => {
+      const n = getPendingMessageCountV2(opts.peer);
+      logger.log(String(n));
+    });
+
+  p2p
+    .command("auto-offline-idle-peers-v2")
+    .description("[V2] Mark idle active peers offline")
+    .option("--now <ms>", "Override current time (ms)")
+    .option("--json", "Output as JSON")
+    .action((opts) => {
+      const list = autoOfflineIdlePeersV2(
+        opts.now ? { now: Number(opts.now) } : undefined,
+      );
+      if (opts.json) console.log(JSON.stringify(list, null, 2));
+      else logger.success(`offlined ${list.length} peer(s)`);
+    });
+
+  p2p
+    .command("auto-fail-stuck-messages-v2")
+    .description("[V2] Fail stuck sending messages")
+    .option("--now <ms>", "Override current time (ms)")
+    .option("--json", "Output as JSON")
+    .action((opts) => {
+      const list = autoFailStuckMessagesV2(
+        opts.now ? { now: Number(opts.now) } : undefined,
+      );
+      if (opts.json) console.log(JSON.stringify(list, null, 2));
+      else logger.success(`failed ${list.length} message(s)`);
+    });
+
+  p2p
+    .command("stats-v2")
+    .description("[V2] Show governance stats")
+    .option("--json", "Output as JSON")
+    .action((opts) => {
+      const s = getP2pManagerStatsV2();
+      if (opts.json) console.log(JSON.stringify(s, null, 2));
+      else logger.log(JSON.stringify(s, null, 2));
+    });
 }

package/src/commands/perception.js

@@ -24,8 +24,53 @@ import {
   crossModalQuery,
   getPerceptionContext,
   getPerceptionStats,
+
+  // Phase 84 V2
+  SENSOR_MATURITY_V2,
+  CAPTURE_LIFECYCLE_V2,
+  getDefaultMaxActiveSensorsPerOperatorV2,
+  getMaxActiveSensorsPerOperatorV2,
+  setMaxActiveSensorsPerOperatorV2,
+  getDefaultMaxPendingCapturesPerSensorV2,
+  getMaxPendingCapturesPerSensorV2,
+  setMaxPendingCapturesPerSensorV2,
+  getDefaultSensorIdleMsV2,
+  getSensorIdleMsV2,
+  setSensorIdleMsV2,
+  getDefaultCaptureStuckMsV2,
+  getCaptureStuckMsV2,
+  setCaptureStuckMsV2,
+  registerSensorV2,
+  getSensorV2,
+  setSensorMaturityV2,
+  activateSensor,
+  degradeSensor,
+  offlineSensor,
+  retireSensor,
+  touchSensorHeartbeat,
+  registerCaptureV2,
+  getCaptureV2,
+  setCaptureStatusV2,
+  startProcessingCapture,
+  markCaptureReady,
+  failCapture,
+  discardCapture,
+  getActiveSensorCount,
+  getPendingCaptureCount,
+  autoOfflineStaleSensors,
+  autoFailStuckProcessingCaptures,
+  getPerceptionStatsV2,
 } from "../lib/perception.js";
 
+function _parseMetaV2(raw) {
+  if (!raw) return undefined;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error("--metadata must be valid JSON");
+  }
+}
+
 function _dbFromCtx(cmd) {
   const root = cmd?.parent?.parent ?? cmd?.parent;
   return root?._db;
@@ -381,5 +426,250 @@ export function registerPerceptionCommand(program) {
       console.log(`Index:    ${s.index.total} entries`);
     });
 
+  /* ═══════════════════════════════════════════════════ *
+   *  Phase 84 V2 — Sensor Maturity + Capture Lifecycle
+   * ═══════════════════════════════════════════════════ */
+
+  perc
+    .command("sensor-maturities-v2")
+    .description("List V2 sensor maturity states")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const xs = Object.values(SENSOR_MATURITY_V2);
+      if (opts.json) return console.log(JSON.stringify(xs, null, 2));
+      for (const x of xs) console.log(`  ${x}`);
+    });
+
+  perc
+    .command("capture-lifecycles-v2")
+    .description("List V2 capture lifecycle states")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const xs = Object.values(CAPTURE_LIFECYCLE_V2);
+      if (opts.json) return console.log(JSON.stringify(xs, null, 2));
+      for (const x of xs) console.log(`  ${x}`);
+    });
+
+  // ── Config defaults/getters/setters ────────────────
+
+  perc
+    .command("default-max-active-sensors-per-operator")
+    .description("Default cap")
+    .action(() => console.log(getDefaultMaxActiveSensorsPerOperatorV2()));
+  perc
+    .command("max-active-sensors-per-operator")
+    .description("Current cap")
+    .action(() => console.log(getMaxActiveSensorsPerOperatorV2()));
+  perc
+    .command("set-max-active-sensors-per-operator <n>")
+    .description("Set cap")
+    .action((n) => console.log(setMaxActiveSensorsPerOperatorV2(n)));
+
+  perc
+    .command("default-max-pending-captures-per-sensor")
+    .description("Default cap")
+    .action(() => console.log(getDefaultMaxPendingCapturesPerSensorV2()));
+  perc
+    .command("max-pending-captures-per-sensor")
+    .description("Current cap")
+    .action(() => console.log(getMaxPendingCapturesPerSensorV2()));
+  perc
+    .command("set-max-pending-captures-per-sensor <n>")
+    .description("Set cap")
+    .action((n) => console.log(setMaxPendingCapturesPerSensorV2(n)));
+
+  perc
+    .command("default-sensor-idle-ms")
+    .description("Default idle ms")
+    .action(() => console.log(getDefaultSensorIdleMsV2()));
+  perc
+    .command("sensor-idle-ms")
+    .description("Current idle ms")
+    .action(() => console.log(getSensorIdleMsV2()));
+  perc
+    .command("set-sensor-idle-ms <ms>")
+    .description("Set idle ms")
+    .action((ms) => console.log(setSensorIdleMsV2(ms)));
+
+  perc
+    .command("default-capture-stuck-ms")
+    .description("Default stuck ms")
+    .action(() => console.log(getDefaultCaptureStuckMsV2()));
+  perc
+    .command("capture-stuck-ms")
+    .description("Current stuck ms")
+    .action(() => console.log(getCaptureStuckMsV2()));
+  perc
+    .command("set-capture-stuck-ms <ms>")
+    .description("Set stuck ms")
+    .action((ms) => console.log(setCaptureStuckMsV2(ms)));
+
+  // ── Counts ─────────────────────────────────────────
+
+  perc
+    .command("active-sensor-count")
+    .description("Count of ACTIVE sensors")
+    .option("-o, --operator <id>", "filter by operator")
+    .action((opts) => console.log(getActiveSensorCount(opts.operator)));
+
+  perc
+    .command("pending-capture-count")
+    .description("Count of PENDING captures")
+    .option("-s, --sensor <id>", "filter by sensor")
+    .action((opts) => console.log(getPendingCaptureCount(opts.sensor)));
+
+  // ── Sensor lifecycle ───────────────────────────────
+
+  perc
+    .command("register-sensor-v2 <sensor-id>")
+    .description("Register a V2 sensor")
+    .requiredOption("-o, --operator <id>", "operator id")
+    .requiredOption("-m, --modality <mod>", "modality")
+    .option("-i, --initial-status <status>", "initial status")
+    .option("--metadata <json>", "metadata JSON")
+    .action((id, opts) => {
+      const r = registerSensorV2(null, {
+        sensorId: id,
+        operatorId: opts.operator,
+        modality: opts.modality,
+        initialStatus: opts.initialStatus,
+        metadata: _parseMetaV2(opts.metadata),
+      });
+      console.log(JSON.stringify(r, null, 2));
+    });
+
+  perc
+    .command("sensor-v2 <sensor-id>")
+    .description("Get a V2 sensor")
+    .action((id) => {
+      const r = getSensorV2(id);
+      if (!r) {
+        console.error(`Unknown sensor: ${id}`);
+        process.exitCode = 1;
+        return;
+      }
+      console.log(JSON.stringify(r, null, 2));
+    });
+
+  perc
+    .command("set-sensor-maturity-v2 <sensor-id> <status>")
+    .description("Transition sensor maturity")
+    .option("-r, --reason <text>", "reason")
+    .option("--metadata <json>", "metadata JSON")
+    .action((id, status, opts) => {
+      const r = setSensorMaturityV2(null, id, status, {
+        reason: opts.reason,
+        metadata: _parseMetaV2(opts.metadata),
+      });
+      console.log(JSON.stringify(r, null, 2));
+    });
+
+  for (const [name, fn] of [
+    ["activate-sensor", activateSensor],
+    ["degrade-sensor", degradeSensor],
+    ["offline-sensor", offlineSensor],
+    ["retire-sensor", retireSensor],
+  ]) {
+    perc
+      .command(`${name} <sensor-id>`)
+      .description(`Transition to ${name.split("-")[0]}`)
+      .option("-r, --reason <text>", "reason")
+      .action((id, opts) => {
+        const r = fn(null, id, opts.reason);
+        console.log(JSON.stringify(r, null, 2));
+      });
+  }
+
+  perc
+    .command("touch-sensor-heartbeat <sensor-id>")
+    .description("Bump lastHeartbeatAt")
+    .action((id) => {
+      const r = touchSensorHeartbeat(id);
+      console.log(JSON.stringify(r, null, 2));
+    });
+
+  // ── Capture lifecycle ──────────────────────────────
+
+  perc
+    .command("register-capture-v2 <capture-id>")
+    .description("Register a V2 capture")
+    .requiredOption("-s, --sensor <id>", "sensor id")
+    .option("-i, --initial-status <status>", "initial status")
+    .option("--metadata <json>", "metadata JSON")
+    .action((id, opts) => {
+      const r = registerCaptureV2(null, {
+        captureId: id,
+        sensorId: opts.sensor,
+        initialStatus: opts.initialStatus,
+        metadata: _parseMetaV2(opts.metadata),
+      });
+      console.log(JSON.stringify(r, null, 2));
+    });
+
+  perc
+    .command("capture-v2 <capture-id>")
+    .description("Get a V2 capture")
+    .action((id) => {
+      const r = getCaptureV2(id);
+      if (!r) {
+        console.error(`Unknown capture: ${id}`);
+        process.exitCode = 1;
+        return;
+      }
+      console.log(JSON.stringify(r, null, 2));
+    });
+
+  perc
+    .command("set-capture-status-v2 <capture-id> <status>")
+    .description("Transition capture lifecycle")
+    .option("-r, --reason <text>", "reason")
+    .option("--metadata <json>", "metadata JSON")
+    .action((id, status, opts) => {
+      const r = setCaptureStatusV2(null, id, status, {
+        reason: opts.reason,
+        metadata: _parseMetaV2(opts.metadata),
+      });
+      console.log(JSON.stringify(r, null, 2));
+    });
+
+  for (const [name, fn] of [
+    ["start-processing-capture", startProcessingCapture],
+    ["mark-capture-ready", markCaptureReady],
+    ["fail-capture", failCapture],
+    ["discard-capture", discardCapture],
+  ]) {
+    perc
+      .command(`${name} <capture-id>`)
+      .description(`Transition capture (${name})`)
+      .option("-r, --reason <text>", "reason")
+      .action((id, opts) => {
+        const r = fn(null, id, opts.reason);
+        console.log(JSON.stringify(r, null, 2));
+      });
+  }
+
+  // ── Auto-flips + stats ─────────────────────────────
+
+  perc
+    .command("auto-offline-stale-sensors")
+    .description("Flip stale ACTIVE/DEGRADED sensors → OFFLINE")
+    .action(() =>
+      console.log(JSON.stringify(autoOfflineStaleSensors(null), null, 2)),
+    );
+
+  perc
+    .command("auto-fail-stuck-processing-captures")
+    .description("Flip stuck PROCESSING captures → FAILED")
+    .action(() =>
+      console.log(
+        JSON.stringify(autoFailStuckProcessingCaptures(null), null, 2),
+      ),
+    );
+
+  perc
+    .command("stats-v2")
+    .description("V2 stats snapshot")
+    .action(() => console.log(JSON.stringify(getPerceptionStatsV2(), null, 2)));
+
   program.addCommand(perc);
 }