chainlesschain 0.66.0 → 0.81.0

package/src/commands/marketplace.js

@@ -18,6 +18,21 @@ import {
   recordInvocation,
   listInvocations,
   getInvocationStats,
+  // V2 (Phase 65)
+  SERVICE_STATUS_V2,
+  INVOCATION_STATUS_V2,
+  PRICING_MODEL_V2,
+  MARKETPLACE_DEFAULT_MAX_CONCURRENT_INVOCATIONS,
+  setMaxConcurrentInvocations,
+  getMaxConcurrentInvocations,
+  getActiveInvocationCount,
+  beginInvocationV2,
+  startInvocation,
+  completeInvocationV2,
+  failInvocationV2,
+  timeoutInvocationV2,
+  setInvocationStatus,
+  getMarketplaceStatsV2,
 } from "../lib/skill-marketplace.js";
 
 function _dbFromCtx(ctx) {
@@ -323,4 +338,245 @@ export function registerMarketplaceCommand(program) {
         process.exit(1);
       }
     });
+
+  /* ── V2 (Phase 65) ───────────────────────────────────────── */
+
+  mp.command("service-statuses-v2")
+    .description("List V2 service statuses (frozen enum)")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const values = Object.values(SERVICE_STATUS_V2);
+      if (options.json) console.log(JSON.stringify(values, null, 2));
+      else for (const v of values) logger.log(`  ${chalk.cyan(v)}`);
+    });
+
+  mp.command("invocation-statuses-v2")
+    .description("List V2 invocation statuses (frozen enum)")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const values = Object.values(INVOCATION_STATUS_V2);
+      if (options.json) console.log(JSON.stringify(values, null, 2));
+      else for (const v of values) logger.log(`  ${chalk.cyan(v)}`);
+    });
+
+  mp.command("pricing-models")
+    .description("List V2 pricing models (frozen enum)")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const values = Object.values(PRICING_MODEL_V2);
+      if (options.json) console.log(JSON.stringify(values, null, 2));
+      else for (const v of values) logger.log(`  ${chalk.cyan(v)}`);
+    });
+
+  mp.command("default-max-concurrent")
+    .description("Show default per-service concurrency cap")
+    .action(() => {
+      logger.log(`  ${MARKETPLACE_DEFAULT_MAX_CONCURRENT_INVOCATIONS}`);
+    });
+
+  mp.command("max-concurrent")
+    .description("Show current per-service concurrency cap")
+    .action(() => {
+      logger.log(`  ${getMaxConcurrentInvocations()}`);
+    });
+
+  mp.command("active-invocation-count [service-id]")
+    .description(
+      "Show count of PENDING + RUNNING invocations (all services by default)",
+    )
+    .action((serviceId) => {
+      logger.log(`  ${getActiveInvocationCount(serviceId)}`);
+    });
+
+  mp.command("set-max-concurrent <n>")
+    .description("Set the per-service concurrency cap")
+    .action((n) => {
+      try {
+        const v = setMaxConcurrentInvocations(Number(n));
+        logger.success(`Max concurrent invocations = ${v}`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  mp.command("begin-v2 <service-id>")
+    .description("Begin a V2 invocation (creates PENDING, enforces cap)")
+    .option("-c, --caller <id>", "Caller ID")
+    .option("-i, --input <json>", "JSON-encoded input")
+    .option("--json", "Output as JSON")
+    .action(async (serviceId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        let input = null;
+        if (options.input) {
+          try {
+            input = JSON.parse(options.input);
+          } catch {
+            input = options.input;
+          }
+        }
+        const inv = beginInvocationV2(db, {
+          serviceId,
+          callerId: options.caller,
+          input,
+        });
+        if (options.json) console.log(JSON.stringify(inv, null, 2));
+        else {
+          logger.success(`Invocation queued [${inv.status}]`);
+          logger.log(`  ${chalk.bold("ID:")} ${chalk.cyan(inv.id)}`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  mp.command("start-invocation <invocation-id>")
+    .description("Start a V2 invocation (PENDING → RUNNING)")
+    .option("--json", "Output as JSON")
+    .action(async (invocationId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const result = startInvocation(db, invocationId);
+        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);
+      }
+    });
+
+  mp.command("complete-invocation <invocation-id>")
+    .description("Complete a V2 invocation (RUNNING → SUCCESS)")
+    .option("-o, --output <json>", "JSON-encoded output")
+    .option("-d, --duration-ms <n>", "Duration in milliseconds", parseInt)
+    .option("--json", "Output as JSON")
+    .action(async (invocationId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        let output = null;
+        if (options.output) {
+          try {
+            output = JSON.parse(options.output);
+          } catch {
+            output = options.output;
+          }
+        }
+        const result = completeInvocationV2(db, invocationId, {
+          output,
+          durationMs: options.durationMs,
+        });
+        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);
+      }
+    });
+
+  mp.command("fail-invocation <invocation-id>")
+    .description("Fail a V2 invocation")
+    .option("-m, --message <msg>", "Error message")
+    .option("-d, --duration-ms <n>", "Duration in milliseconds", parseInt)
+    .action(async (invocationId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const result = failInvocationV2(db, invocationId, options.message, {
+          durationMs: options.durationMs,
+        });
+        logger.success(`Status = ${result.status}`);
+        if (result.error) logger.log(`  Error: ${result.error}`);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  mp.command("timeout-invocation <invocation-id>")
+    .description("Timeout a V2 invocation")
+    .option("-d, --duration-ms <n>", "Duration in milliseconds", parseInt)
+    .action(async (invocationId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const result = timeoutInvocationV2(db, invocationId, {
+          durationMs: options.durationMs,
+        });
+        logger.success(`Status = ${result.status}`);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  mp.command("set-invocation-status <invocation-id> <status>")
+    .description("Set V2 invocation status via the state machine")
+    .option("-m, --message <msg>", "Error message (FAILED/TIMEOUT)")
+    .option("--json", "Output as JSON")
+    .action(async (invocationId, status, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const patch = options.message ? { error: options.message } : {};
+        const result = setInvocationStatus(db, invocationId, 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);
+      }
+    });
+
+  mp.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 = getMarketplaceStatsV2();
+        if (options.json) console.log(JSON.stringify(stats, null, 2));
+        else {
+          logger.log(
+            `  ${chalk.bold("Services:")}       ${stats.totalServices}`,
+          );
+          logger.log(
+            `  ${chalk.bold("Invocations:")}    ${stats.totalInvocations} (active: ${stats.activeInvocations})`,
+          );
+          logger.log(
+            `  ${chalk.bold("Max concurrent:")} ${stats.maxConcurrentInvocations}`,
+          );
+          logger.log(`  ${chalk.bold("Services by status:")}`);
+          for (const [k, v] of Object.entries(stats.servicesByStatus))
+            logger.log(`    ${k.padEnd(12)} ${v}`);
+          logger.log(`  ${chalk.bold("Services by pricing:")}`);
+          for (const [k, v] of Object.entries(stats.servicesByPricing))
+            logger.log(`    ${k.padEnd(14)} ${v}`);
+          logger.log(`  ${chalk.bold("Invocations by status:")}`);
+          for (const [k, v] of Object.entries(stats.invocationsByStatus))
+            logger.log(`    ${k.padEnd(10)} ${v}`);
+          logger.log(
+            `  ${chalk.bold("Success rate:")}   ${(stats.successRate * 100).toFixed(1)}%`,
+          );
+          logger.log(
+            `  ${chalk.bold("Avg duration:")}   ${stats.avgDurationMs}ms`,
+          );
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
 }

package/src/commands/privacy.js

@@ -23,6 +23,32 @@ import {
   dpPublish,
   heQuery,
   getPrivacyReport,
+  // V2 surface
+  FL_STATUS_V2,
+  MPC_STATUS_V2,
+  DP_MECHANISM_V2,
+  HE_SCHEME_V2,
+  MPC_PROTOCOL_V2,
+  PRIVACY_DEFAULT_MAX_ACTIVE_MPC_COMPUTATIONS,
+  setMaxActiveMpcComputations,
+  getMaxActiveMpcComputations,
+  getActiveMpcCount,
+  setPrivacyBudgetLimit,
+  getPrivacyBudgetLimit,
+  getPrivacyBudgetSpent,
+  resetPrivacyBudget,
+  createModelV2,
+  trainRoundV2,
+  aggregateRound,
+  failModelV2,
+  setFLStatusV2,
+  createComputationV2,
+  submitShareV2,
+  failComputation,
+  setMPCStatusV2,
+  dpPublishV2,
+  heQueryV2,
+  getPrivacyStatsV2,
 } from "../lib/privacy-computing.js";
 
 function _dbFromCtx(cmd) {
@@ -341,5 +367,300 @@ export function registerPrivacyCommand(program) {
       );
     });
 
+  /* ──────────────────────────────────────────────────────────
+   *  V2 — Phase 91
+   * ────────────────────────────────────────────────────────── */
+
+  pc.command("fl-statuses-v2")
+    .description("List V2 FL statuses")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const v = Object.values(FL_STATUS_V2);
+      if (opts.json) return console.log(JSON.stringify(v, null, 2));
+      v.forEach((s) => console.log(s));
+    });
+
+  pc.command("mpc-statuses-v2")
+    .description("List V2 MPC statuses")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const v = Object.values(MPC_STATUS_V2);
+      if (opts.json) return console.log(JSON.stringify(v, null, 2));
+      v.forEach((s) => console.log(s));
+    });
+
+  pc.command("dp-mechanisms-v2")
+    .description("List V2 DP mechanisms")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const v = Object.values(DP_MECHANISM_V2);
+      if (opts.json) return console.log(JSON.stringify(v, null, 2));
+      v.forEach((s) => console.log(s));
+    });
+
+  pc.command("he-schemes-v2")
+    .description("List V2 HE schemes")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const v = Object.values(HE_SCHEME_V2);
+      if (opts.json) return console.log(JSON.stringify(v, null, 2));
+      v.forEach((s) => console.log(s));
+    });
+
+  pc.command("mpc-protocols-v2")
+    .description("List V2 MPC protocols")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const v = Object.values(MPC_PROTOCOL_V2);
+      if (opts.json) return console.log(JSON.stringify(v, null, 2));
+      v.forEach((s) => console.log(s));
+    });
+
+  pc.command("default-max-active-mpc")
+    .description("Show V2 default max active MPC computations")
+    .action(() =>
+      console.log(String(PRIVACY_DEFAULT_MAX_ACTIVE_MPC_COMPUTATIONS)),
+    );
+
+  pc.command("max-active-mpc")
+    .description("Show current max active MPC computations")
+    .action(() => console.log(String(getMaxActiveMpcComputations())));
+
+  pc.command("active-mpc-count")
+    .description("Show currently-active MPC computation count")
+    .action(() => console.log(String(getActiveMpcCount())));
+
+  pc.command("set-max-active-mpc <n>")
+    .description("Set max concurrent active MPC computations")
+    .action((n) => {
+      setMaxActiveMpcComputations(Number(n));
+      console.log(`max-active-mpc = ${getMaxActiveMpcComputations()}`);
+    });
+
+  pc.command("budget-limit")
+    .description("Show privacy budget limit")
+    .action(() => console.log(String(getPrivacyBudgetLimit())));
+
+  pc.command("budget-spent")
+    .description("Show privacy budget spent")
+    .action(() => console.log(String(getPrivacyBudgetSpent())));
+
+  pc.command("set-budget-limit <n>")
+    .description("Set privacy budget limit")
+    .action((n) => {
+      setPrivacyBudgetLimit(Number(n));
+      console.log(`budget-limit = ${getPrivacyBudgetLimit()}`);
+    });
+
+  pc.command("reset-budget")
+    .description("Reset privacy budget spent counter to 0")
+    .action(() => {
+      resetPrivacyBudget();
+      console.log("budget reset");
+    });
+
+  pc.command("create-model-v2 <name>")
+    .description("V2 create FL model (throws on invalid input)")
+    .option("-t, --total-rounds <n>", "Total rounds (default 10)")
+    .option("-l, --learning-rate <n>", "Learning rate (default 0.01)")
+    .option("-a, --architecture <arch>", "Architecture")
+    .option("-m, --model-type <type>", "Model type")
+    .option("--json", "JSON output")
+    .action((name, opts) => {
+      const db = _dbFromCtx(pc);
+      const m = createModelV2(db, {
+        name,
+        totalRounds: opts.totalRounds ? Number(opts.totalRounds) : undefined,
+        learningRate: opts.learningRate ? Number(opts.learningRate) : undefined,
+        architecture: opts.architecture,
+        modelType: opts.modelType,
+      });
+      if (opts.json) return console.log(JSON.stringify(m, null, 2));
+      console.log(`Model: ${m.id} (${m.name}, rounds=${m.total_rounds})`);
+    });
+
+  pc.command("train-round-v2 <model-id>")
+    .description("V2 train one FL round (auto initializing → training)")
+    .option("--json", "JSON output")
+    .action((id, opts) => {
+      const db = _dbFromCtx(pc);
+      const m = trainRoundV2(db, id);
+      if (opts.json) return console.log(JSON.stringify(m, null, 2));
+      console.log(
+        `Round ${m.current_round}/${m.total_rounds}  status=${m.status}  acc=${m.accuracy}`,
+      );
+    });
+
+  pc.command("aggregate-round <model-id>")
+    .description("Aggregate FL round (training → training next / completed)")
+    .option("--json", "JSON output")
+    .action((id, opts) => {
+      const db = _dbFromCtx(pc);
+      const m = aggregateRound(db, id);
+      if (opts.json) return console.log(JSON.stringify(m, null, 2));
+      console.log(`Model ${m.id} status=${m.status} round=${m.current_round}`);
+    });
+
+  pc.command("fail-model-v2 <model-id>")
+    .description("V2 fail FL model (any non-terminal → failed)")
+    .option("-e, --error <msg>", "Error message")
+    .option("--json", "JSON output")
+    .action((id, opts) => {
+      const db = _dbFromCtx(pc);
+      const m = failModelV2(db, id, { error: opts.error });
+      if (opts.json) return console.log(JSON.stringify(m, null, 2));
+      console.log(`Model ${m.id} failed: ${m.error_message || ""}`);
+    });
+
+  pc.command("set-fl-status <model-id> <status>")
+    .description("V2 state-machine guarded FL status setter")
+    .option("-a, --accuracy <n>")
+    .option("-l, --loss <n>")
+    .option("-e, --error <msg>")
+    .option("--json", "JSON output")
+    .action((id, status, opts) => {
+      const db = _dbFromCtx(pc);
+      const patch = {};
+      if (opts.accuracy !== undefined) patch.accuracy = Number(opts.accuracy);
+      if (opts.loss !== undefined) patch.loss = Number(opts.loss);
+      if (opts.error !== undefined) patch.errorMessage = opts.error;
+      const m = setFLStatusV2(db, id, status, patch);
+      if (opts.json) return console.log(JSON.stringify(m, null, 2));
+      console.log(`Model ${m.id} status=${m.status}`);
+    });
+
+  pc.command("create-computation-v2 <type>")
+    .description("V2 create MPC computation (throws on invalid input)")
+    .option("-p, --protocol <proto>", "Protocol (shamir|beaver|gmw)")
+    .option("-i, --participants <csv>", "Comma-separated participant IDs")
+    .option("-s, --shares-required <n>", "Shares required")
+    .option("--json", "JSON output")
+    .action((type, opts) => {
+      const db = _dbFromCtx(pc);
+      const ids = opts.participants
+        ? opts.participants
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean)
+        : [];
+      const c = createComputationV2(db, {
+        computationType: type,
+        protocol: opts.protocol,
+        participantIds: ids,
+        sharesRequired: opts.sharesRequired
+          ? Number(opts.sharesRequired)
+          : undefined,
+      });
+      if (opts.json) return console.log(JSON.stringify(c, null, 2));
+      console.log(
+        `Computation: ${c.id}  protocol=${c.protocol}  required=${c.shares_required}`,
+      );
+    });
+
+  pc.command("submit-share-v2 <comp-id>")
+    .description("V2 submit MPC share (state-guarded)")
+    .option("--json", "JSON output")
+    .action((id, opts) => {
+      const db = _dbFromCtx(pc);
+      const c = submitShareV2(db, id);
+      if (opts.json) return console.log(JSON.stringify(c, null, 2));
+      console.log(
+        `Comp ${c.id} shares=${c.shares_received}/${c.shares_required} status=${c.status}`,
+      );
+    });
+
+  pc.command("fail-computation <comp-id>")
+    .description("Fail MPC computation (any non-terminal → failed)")
+    .option("-e, --error <msg>")
+    .option("--json", "JSON output")
+    .action((id, opts) => {
+      const db = _dbFromCtx(pc);
+      const c = failComputation(db, id, { error: opts.error });
+      if (opts.json) return console.log(JSON.stringify(c, null, 2));
+      console.log(`Comp ${c.id} failed: ${c.error_message || ""}`);
+    });
+
+  pc.command("set-mpc-status <comp-id> <status>")
+    .description("V2 state-machine guarded MPC status setter")
+    .option("-h, --result-hash <hash>")
+    .option("-e, --error <msg>")
+    .option("--json", "JSON output")
+    .action((id, status, opts) => {
+      const db = _dbFromCtx(pc);
+      const patch = {};
+      if (opts.resultHash !== undefined) patch.resultHash = opts.resultHash;
+      if (opts.error !== undefined) patch.errorMessage = opts.error;
+      const c = setMPCStatusV2(db, id, status, patch);
+      if (opts.json) return console.log(JSON.stringify(c, null, 2));
+      console.log(`Comp ${c.id} status=${c.status}`);
+    });
+
+  pc.command("dp-publish-v2")
+    .description("V2 DP publish (throws on invalid input / exceeded budget)")
+    .requiredOption("-d, --data <n>", "Data value", Number)
+    .option("-e, --epsilon <n>", "Epsilon", Number)
+    .option("--delta <n>", "Delta", Number)
+    .option("-m, --mechanism <mech>", "Mechanism")
+    .option("-s, --sensitivity <n>", "Sensitivity", Number)
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const db = _dbFromCtx(pc);
+      const r = dpPublishV2(db, {
+        data: opts.data,
+        epsilon: opts.epsilon,
+        delta: opts.delta,
+        mechanism: opts.mechanism,
+        sensitivity: opts.sensitivity,
+      });
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      console.log(
+        `Published: orig=${r.originalValue}  noised=${r.noisedValue}  ε=${r.epsilon}`,
+      );
+    });
+
+  pc.command("he-query-v2")
+    .description("V2 HE query (throws on invalid input)")
+    .requiredOption("-o, --operation <op>", "sum|product|mean|count")
+    .requiredOption("-d, --data <json>", "JSON array of numbers")
+    .option("-s, --scheme <scheme>", "Scheme")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      let data;
+      try {
+        data = JSON.parse(opts.data);
+      } catch (_e) {
+        throw new Error("Invalid --data JSON");
+      }
+      const r = heQueryV2({
+        data,
+        operation: opts.operation,
+        scheme: opts.scheme,
+      });
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      console.log(
+        `Result: ${r.result}  (${r.operation} over ${r.inputCount} items, scheme=${r.scheme})`,
+      );
+    });
+
+  pc.command("stats-v2")
+    .description("V2 all-enum-key zero-init stats")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const s = getPrivacyStatsV2();
+      if (opts.json) return console.log(JSON.stringify(s, null, 2));
+      console.log(
+        `Models: ${s.totalModels}  Computations: ${s.totalComputations}`,
+      );
+      console.log(
+        `Active MPC: ${s.activeMpcCount}/${s.maxActiveMpcComputations}`,
+      );
+      console.log(
+        `Budget: ${s.budget.spent}/${s.budget.limit} (${s.budget.remaining} remaining)`,
+      );
+      console.log(
+        `Avg accuracy: ${s.avgAccuracy}  Avg comp time ms: ${s.avgComputationTimeMs}`,
+      );
+    });
+
   program.addCommand(pc);
 }