chainlesschain 0.49.0 → 0.66.0

package/src/commands/workflow.js

@@ -16,7 +16,20 @@ import {
   rollbackExecution,
   getTemplates,
   deleteWorkflow,
+  TEMPLATE_TYPE,
+  WORKFLOW_STATUS,
+  NODE_STATUS,
+  listTemplates,
+  createCheckpoint,
+  listCheckpoints,
+  rollbackToCheckpoint,
+  setBreakpoint,
+  listBreakpoints,
+  removeBreakpoint,
+  exportWorkflow,
+  importWorkflow,
 } from "../lib/workflow-engine.js";
+import fs from "fs";
 
 export function registerWorkflowCommand(program) {
   const workflow = program
@@ -356,4 +369,311 @@ export function registerWorkflowCommand(program) {
         process.exit(1);
       }
     });
+
+  // workflow canonical-templates (Phase 82)
+  workflow
+    .command("canonical-templates")
+    .description(
+      "List 5 canonical Phase 82 templates (ci_cd/data_pipeline/...)",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const templates = listTemplates();
+        if (options.json) {
+          console.log(JSON.stringify(templates, null, 2));
+        } else {
+          logger.log(
+            chalk.bold(`Canonical Phase 82 Templates (${templates.length}):\n`),
+          );
+          for (const tpl of templates) {
+            logger.log(`  ${chalk.cyan(tpl.id)} — ${tpl.name}`);
+            logger.log(`    ${chalk.gray(tpl.description)}`);
+            logger.log(
+              `    Stages: ${tpl.stages.map((s) => s.name).join(" → ")}`,
+            );
+            logger.log("");
+          }
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // workflow statuses (Phase 82) — enum reference
+  workflow
+    .command("statuses")
+    .description("Show workflow and node status enum values (Phase 82)")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      const payload = {
+        workflow: WORKFLOW_STATUS,
+        node: NODE_STATUS,
+        template: TEMPLATE_TYPE,
+      };
+      if (options.json) {
+        console.log(JSON.stringify(payload, null, 2));
+      } else {
+        logger.log(chalk.bold("Workflow statuses:"));
+        for (const v of Object.values(WORKFLOW_STATUS)) {
+          logger.log(`  ${chalk.cyan(v)}`);
+        }
+        logger.log(chalk.bold("\nNode statuses:"));
+        for (const v of Object.values(NODE_STATUS)) {
+          logger.log(`  ${chalk.cyan(v)}`);
+        }
+        logger.log(chalk.bold("\nTemplate types:"));
+        for (const v of Object.values(TEMPLATE_TYPE)) {
+          logger.log(`  ${chalk.cyan(v)}`);
+        }
+      }
+    });
+
+  // workflow checkpoint <exec-id>
+  workflow
+    .command("checkpoint <exec-id>")
+    .description("Create a checkpoint snapshot of an execution")
+    .option("--json", "Output as JSON")
+    .action(async (execId, 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();
+        const cp = createCheckpoint(db, execId);
+        if (options.json) {
+          console.log(JSON.stringify(cp, null, 2));
+        } else {
+          logger.log(chalk.green(`Checkpoint created: ${cp.id}`));
+          logger.log(`  Execution: ${cp.executionId}`);
+          logger.log(`  Workflow:  ${cp.workflowId}`);
+          logger.log(`  Captured:  ${cp.snapshot.capturedAt}`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // workflow checkpoints <exec-id>
+  workflow
+    .command("checkpoints <exec-id>")
+    .description("List checkpoints for an execution")
+    .option("--json", "Output as JSON")
+    .action(async (execId, 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();
+        const list = listCheckpoints(db, execId);
+        if (options.json) {
+          console.log(JSON.stringify(list, null, 2));
+        } else if (list.length === 0) {
+          logger.info("No checkpoints for this execution.");
+        } else {
+          logger.log(chalk.bold(`Checkpoints (${list.length}):\n`));
+          for (const cp of list) {
+            logger.log(
+              `  ${chalk.cyan(cp.id)} — ${cp.createdAt} (stage: ${cp.snapshot.currentStage || "?"})`,
+            );
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // workflow rollback-to <exec-id> <checkpoint-id>
+  workflow
+    .command("rollback-to <exec-id> <checkpoint-id>")
+    .description("Rollback an execution to a specific checkpoint")
+    .action(async (execId, cpId) => {
+      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();
+        const result = rollbackToCheckpoint(db, execId, cpId);
+        logger.log(
+          chalk.yellow(
+            `Rolled back execution ${result.id} to checkpoint ${result.checkpointId}`,
+          ),
+        );
+        logger.log(`  Status: ${chalk.cyan(result.status)}`);
+        if (result.restoredStage) {
+          logger.log(`  Restored stage: ${result.restoredStage}`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // workflow breakpoint-set <wf-id> <node-id> [condition]
+  workflow
+    .command("breakpoint-set <wf-id> <node-id>")
+    .description("Set a breakpoint on a workflow node (optionally conditional)")
+    .option(
+      "-c, --condition <expr>",
+      "Conditional expression, e.g. 'input.priority > 5'",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (wfId, nodeId, 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();
+        const bp = setBreakpoint(db, wfId, nodeId, options.condition || null);
+        if (options.json) {
+          console.log(JSON.stringify(bp, null, 2));
+        } else {
+          logger.log(chalk.green(`Breakpoint set: ${bp.id}`));
+          logger.log(`  Node: ${chalk.cyan(bp.nodeId)}`);
+          if (bp.condition) logger.log(`  Condition: ${bp.condition}`);
+          else logger.log(`  Condition: ${chalk.gray("(unconditional)")}`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // workflow breakpoints <wf-id>
+  workflow
+    .command("breakpoints <wf-id>")
+    .description("List breakpoints on a workflow")
+    .option("--json", "Output as JSON")
+    .action(async (wfId, 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();
+        const list = listBreakpoints(db, wfId);
+        if (options.json) {
+          console.log(JSON.stringify(list, null, 2));
+        } else if (list.length === 0) {
+          logger.info("No breakpoints for this workflow.");
+        } else {
+          logger.log(chalk.bold(`Breakpoints (${list.length}):\n`));
+          for (const bp of list) {
+            logger.log(
+              `  ${chalk.cyan(bp.id)} @ node=${bp.nodeId} ${bp.enabled ? chalk.green("enabled") : chalk.gray("disabled")}`,
+            );
+            if (bp.condition) logger.log(`    when: ${bp.condition}`);
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // workflow breakpoint-remove <bp-id>
+  workflow
+    .command("breakpoint-remove <bp-id>")
+    .description("Remove a breakpoint")
+    .action(async (bpId) => {
+      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();
+        const result = removeBreakpoint(db, bpId);
+        if (result.removed) {
+          logger.log(chalk.green(`Breakpoint removed: ${bpId}`));
+        } else {
+          logger.warn(`Breakpoint not found: ${bpId}`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // workflow export <wf-id>
+  workflow
+    .command("export <wf-id>")
+    .description("Export a workflow as a JSON definition")
+    .option("-o, --output <file>", "Write to file instead of stdout")
+    .action(async (wfId, 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();
+        const def = exportWorkflow(db, wfId);
+        const json = JSON.stringify(def, null, 2);
+        if (options.output) {
+          fs.writeFileSync(options.output, json, "utf-8");
+          logger.log(chalk.green(`Exported to ${options.output}`));
+        } else {
+          console.log(json);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // workflow import <file>
+  workflow
+    .command("import <file>")
+    .description("Import a workflow from a JSON definition file")
+    .option("--json", "Output as JSON")
+    .action(async (file, options) => {
+      try {
+        const raw = fs.readFileSync(file, "utf-8");
+        let def;
+        try {
+          def = JSON.parse(raw);
+        } catch (_err) {
+          logger.error(`Invalid JSON in ${file}`);
+          process.exit(1);
+        }
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const result = importWorkflow(db, def);
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.log(chalk.green(`Workflow imported: ${result.id}`));
+          logger.log(`  Name: ${chalk.cyan(def.name)}`);
+          logger.log(`  Stages: ${result.stages.length}`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
 }

package/src/commands/zkp.js

@@ -15,6 +15,13 @@ import {
   getZKPStats,
   listCircuits,
   listProofs,
+  PROOF_SCHEME,
+  CIRCUIT_STATUS,
+  SUPPORTED_SCHEMES,
+  setCircuitStatus,
+  registerCredential,
+  selectiveDisclose,
+  listCredentials,
 } from "../lib/zkp-engine.js";
 
 export function registerZkpCommand(program) {
@@ -61,6 +68,7 @@ export function registerZkpCommand(program) {
     .description("Generate a zero-knowledge proof")
     .option("--private <json>", "Private inputs as JSON")
     .option("--public <json>", "Public inputs as JSON")
+    .option("--scheme <scheme>", "Proof scheme (groth16|plonk|bulletproofs)")
     .option("--json", "Output as JSON")
     .action(async (circuitId, options) => {
       try {
@@ -76,7 +84,14 @@ export function registerZkpCommand(program) {
           ? JSON.parse(options.private)
           : {};
         const publicInputs = options.public ? JSON.parse(options.public) : [];
-        const proof = generateProof(db, circuitId, privateInputs, publicInputs);
+        const proveOpts = options.scheme ? { scheme: options.scheme } : {};
+        const proof = generateProof(
+          db,
+          circuitId,
+          privateInputs,
+          publicInputs,
+          proveOpts,
+        );
 
         if (options.json) {
           console.log(JSON.stringify(proof, null, 2));
@@ -188,6 +203,27 @@ export function registerZkpCommand(program) {
           logger.log(
             `  ${chalk.bold("Verified:")}       ${stats.verifiedProofs}`,
           );
+          if (stats.credentials !== undefined) {
+            logger.log(
+              `  ${chalk.bold("Credentials:")}    ${stats.credentials}`,
+            );
+          }
+          if (stats.proofsByScheme) {
+            logger.log(`  ${chalk.bold("By scheme:")}`);
+            for (const [scheme, count] of Object.entries(
+              stats.proofsByScheme,
+            )) {
+              logger.log(`    ${scheme}: ${count}`);
+            }
+          }
+          if (stats.circuitsByStatus) {
+            logger.log(`  ${chalk.bold("Circuit status:")}`);
+            for (const [status, count] of Object.entries(
+              stats.circuitsByStatus,
+            )) {
+              logger.log(`    ${status}: ${count}`);
+            }
+          }
         }
 
         await shutdown();
@@ -268,6 +304,196 @@ export function registerZkpCommand(program) {
           }
         }
 
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // zkp schemes
+  zkp
+    .command("schemes")
+    .description("List supported proof schemes and circuit statuses")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      try {
+        const payload = {
+          schemes: Array.from(SUPPORTED_SCHEMES),
+          proofSchemes: { ...PROOF_SCHEME },
+          circuitStatuses: { ...CIRCUIT_STATUS },
+        };
+        if (options.json) {
+          console.log(JSON.stringify(payload, null, 2));
+        } else {
+          logger.log(chalk.bold("Proof schemes:"));
+          for (const [key, val] of Object.entries(PROOF_SCHEME)) {
+            logger.log(`  ${chalk.cyan(key)} → ${val}`);
+          }
+          logger.log(chalk.bold("Circuit statuses:"));
+          for (const [key, val] of Object.entries(CIRCUIT_STATUS)) {
+            logger.log(`  ${chalk.cyan(key)} → ${val}`);
+          }
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // zkp set-status
+  zkp
+    .command("set-status <circuit-id> <status>")
+    .description("Update circuit status (draft|compiled|verified|failed)")
+    .action(async (circuitId, 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();
+        ensureZKPTables(db);
+
+        const result = setCircuitStatus(db, circuitId, status);
+        logger.success(
+          `Circuit ${chalk.cyan(circuitId.slice(0, 8))} → ${chalk.bold(result.status)}`,
+        );
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // zkp register-credential
+  zkp
+    .command("register-credential")
+    .description("Register a credential with selective-disclosure merkle root")
+    .option("--did <did>", "Subject DID")
+    .option("--claims <json>", "Credential claims as JSON")
+    .option("--json", "Output as 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();
+        ensureZKPTables(db);
+
+        const claims = options.claims ? JSON.parse(options.claims) : {};
+        const cred = registerCredential(db, {
+          did: options.did,
+          claims,
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(cred, null, 2));
+        } else {
+          logger.success("Credential registered");
+          logger.log(`  ${chalk.bold("ID:")}          ${chalk.cyan(cred.id)}`);
+          logger.log(`  ${chalk.bold("DID:")}         ${cred.did || "-"}`);
+          logger.log(
+            `  ${chalk.bold("MerkleRoot:")}  ${cred.merkleRoot.slice(0, 16)}...`,
+          );
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // zkp disclose
+  zkp
+    .command("disclose <credential-id> <fields>")
+    .description(
+      "Selectively disclose credential fields (comma-separated field list)",
+    )
+    .option("--to <did>", "Recipient DID")
+    .option("--json", "Output as JSON")
+    .action(async (credentialId, fields, 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();
+        ensureZKPTables(db);
+
+        const disclosed = fields
+          .split(",")
+          .map((s) => s.trim())
+          .filter(Boolean);
+        const result = selectiveDisclose(
+          db,
+          credentialId,
+          disclosed,
+          options.to,
+        );
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.success("Selective disclosure created");
+          logger.log(
+            `  ${chalk.bold("ID:")}          ${chalk.cyan(result.id)}`,
+          );
+          logger.log(`  ${chalk.bold("Credential:")}  ${result.credentialId}`);
+          logger.log(
+            `  ${chalk.bold("Disclosed:")}   ${JSON.stringify(result.disclosed)}`,
+          );
+          logger.log(
+            `  ${chalk.bold("Hidden:")}      ${result.hiddenCount} field(s)`,
+          );
+          logger.log(
+            `  ${chalk.bold("MerkleRoot:")}  ${result.merkleRoot.slice(0, 16)}...`,
+          );
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // zkp credentials
+  zkp
+    .command("credentials")
+    .description("List registered credentials")
+    .option("--did <did>", "Filter by subject DID")
+    .option("--json", "Output as 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();
+        ensureZKPTables(db);
+
+        const creds = listCredentials(db, { did: options.did });
+        if (options.json) {
+          console.log(JSON.stringify(creds, null, 2));
+        } else {
+          if (creds.length === 0) {
+            logger.log("No credentials registered");
+          } else {
+            for (const c of creds) {
+              logger.log(
+                `  ${chalk.cyan(c.id.slice(0, 8))} ${c.did || "(no-did)"} — root ${c.merkleRoot.slice(0, 12)}...`,
+              );
+            }
+          }
+        }
+
         await shutdown();
       } catch (err) {
         logger.error(`Failed: ${err.message}`);

package/src/index.js

@@ -157,6 +157,24 @@ import { registerNlProgCommand } from "./commands/nlprog.js";
 import { registerQuantizationCommand } from "./commands/quantization.js";
 // Phase 63: Universal Runtime
 import { registerRuntimeCommand } from "./commands/runtime.js";
+// Phase 17: IPFS decentralized storage
+import { registerIpfsCommand } from "./commands/ipfs.js";
+// Phase 27: Multimodal Collaboration
+import { registerMultimodalCommand } from "./commands/multimodal.js";
+// Phase 22: Performance auto-tuning
+import { registerPerfCommand } from "./commands/perf.js";
+// Phase 24: Decentralized Agent Network
+import { registerAgentNetworkCommand } from "./commands/agent-network.js";
+// Phase 55: DID v2.0 — W3C DID + Verifiable Presentations + social recovery
+import { registerDIDv2Command } from "./commands/did-v2.js";
+// Phase 26: Development Pipeline Orchestration (7-stage AI pipeline + gates)
+import { registerPipelineCommand } from "./commands/pipeline.js";
+// Phase 64: Plugin Ecosystem 2.0 (registry + deps + install + AI review + publish + revenue)
+import { registerPluginEcosystemCommand } from "./commands/plugin-ecosystem.js";
+// Phase 96: Workflow Automation Engine (12 SaaS connectors + 5 triggers + DAG execution)
+import { registerAutomationCommand } from "./commands/automation.js";
+// Phase 14: SSO Enterprise Authentication (SAML / OAuth2 / OIDC + session lifecycle + DID bridge)
+import { registerSsoCommand } from "./commands/sso.js";
 
 export function createProgram() {
   const program = new Command();
@@ -336,6 +354,15 @@ export function createProgram() {
   registerNlProgCommand(program);
   registerQuantizationCommand(program);
   registerRuntimeCommand(program);
+  registerIpfsCommand(program);
+  registerMultimodalCommand(program);
+  registerPerfCommand(program);
+  registerAgentNetworkCommand(program);
+  registerDIDv2Command(program);
+  registerPipelineCommand(program);
+  registerPluginEcosystemCommand(program);
+  registerAutomationCommand(program);
+  registerSsoCommand(program);
 
   return program;
 }