chainlesschain 0.66.0 → 0.132.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chainlesschain",
-  "version": "0.66.0",
+  "version": "0.132.0",
   "description": "CLI for ChainlessChain - install, configure, and manage your personal AI management system",
   "type": "module",
   "bin": {

package/src/commands/a2a.js

@@ -17,6 +17,26 @@ import {
   getTaskStatus,
   negotiateCapability,
   listPeers,
+  // V2 (Phase 81)
+  TASK_STATUS_V2,
+  CARD_STATUS_V2,
+  SUBSCRIPTION_TYPE,
+  NEGOTIATION_RESULT,
+  validateAgentCard,
+  setCardStatus,
+  getCardStatusV2,
+  sendTaskV2,
+  startWorking,
+  requestInput,
+  provideInput,
+  completeTaskV2,
+  failTaskV2,
+  cancelTask,
+  checkTaskTimeout,
+  getTaskV2,
+  listTasksV2,
+  negotiateCapabilityV2,
+  getA2AStatsV2,
 } from "../lib/a2a-protocol.js";
 
 export function registerA2aCommand(program) {
@@ -371,4 +391,364 @@ export function registerA2aCommand(program) {
         process.exit(1);
       }
     });
+
+  // ═══════════════════════════════════════════════════════════════
+  // Phase 81 — A2A Protocol V2
+  // ═══════════════════════════════════════════════════════════════
+
+  // Enum listings (no DB required)
+  a2a
+    .command("task-statuses")
+    .description("List V2 task statuses (Phase 81)")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const statuses = Object.values(TASK_STATUS_V2);
+      if (options.json) console.log(JSON.stringify(statuses, null, 2));
+      else statuses.forEach((s) => logger.log(`  ${s}`));
+    });
+
+  a2a
+    .command("card-statuses")
+    .description("List V2 card statuses (Phase 81)")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const statuses = Object.values(CARD_STATUS_V2);
+      if (options.json) console.log(JSON.stringify(statuses, null, 2));
+      else statuses.forEach((s) => logger.log(`  ${s}`));
+    });
+
+  a2a
+    .command("subscription-types")
+    .description("List V2 subscription types (Phase 81)")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const types = Object.values(SUBSCRIPTION_TYPE);
+      if (options.json) console.log(JSON.stringify(types, null, 2));
+      else types.forEach((t) => logger.log(`  ${t}`));
+    });
+
+  a2a
+    .command("negotiation-results")
+    .description("List V2 negotiation outcomes (Phase 81)")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const outcomes = Object.values(NEGOTIATION_RESULT);
+      if (options.json) console.log(JSON.stringify(outcomes, null, 2));
+      else outcomes.forEach((o) => logger.log(`  ${o}`));
+    });
+
+  // validate-card — pure, no DB
+  a2a
+    .command("validate-card")
+    .description("Validate an agent card against the A2A schema")
+    .argument("<name>", "Agent name")
+    .option("--description <desc>", "Description", "")
+    .option("--url <url>", "URL", "")
+    .option("--capabilities <csv>", "Capabilities CSV", "")
+    .option("--skills <csv>", "Skills CSV", "")
+    .option("--card-version <semver>", "Card version (major.minor.patch)")
+    .option("--auth-type <t>", "Auth type (none|bearer|basic|oauth2)")
+    .option("--json", "Output as JSON")
+    .action((name, options) => {
+      const card = {
+        name,
+        description: options.description,
+        url: options.url,
+        capabilities: options.capabilities
+          ? options.capabilities.split(",").map((s) => s.trim())
+          : [],
+        skills: options.skills
+          ? options.skills.split(",").map((s) => s.trim())
+          : [],
+      };
+      if (options.cardVersion) card.version = options.cardVersion;
+      if (options.authType) card.auth_type = options.authType;
+      const result = validateAgentCard(card);
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else if (result.valid) {
+        logger.success("Card is valid");
+      } else {
+        logger.warn("Card is invalid");
+        result.errors.forEach((e) => logger.log(`  - ${e}`));
+        process.exit(1);
+      }
+    });
+
+  // set-card-status <cardId> <status>
+  a2a
+    .command("set-card-status")
+    .description("Transition a card between active/inactive/expired")
+    .argument("<cardId>", "Card ID")
+    .argument("<status>", "active|inactive|expired")
+    .option("--json", "Output as JSON")
+    .action(async (cardId, status, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = ctx.db?.getDatabase?.() || null;
+        const result = setCardStatus(db, cardId, status);
+        if (options.json) console.log(JSON.stringify(result, null, 2));
+        else logger.success(`Card ${cardId} → ${status}`);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // card-status <cardId>
+  a2a
+    .command("card-status")
+    .description("Show a card's V2 status")
+    .argument("<cardId>", "Card ID")
+    .option("--json", "Output as JSON")
+    .action((cardId, options) => {
+      const status = getCardStatusV2(cardId);
+      if (options.json) console.log(JSON.stringify({ cardId, status }));
+      else logger.log(`${cardId}: ${status}`);
+    });
+
+  // send-task-v2 <agentId> <input> [--timeout-ms N]
+  a2a
+    .command("send-task-v2")
+    .description("Submit a V2 task (in-memory, with optional timeout)")
+    .argument("<agentId>", "Agent ID")
+    .argument("<input>", "Task input")
+    .option("--timeout-ms <ms>", "Timeout in ms", parseInt)
+    .option("--json", "Output as JSON")
+    .action((agentId, input, options) => {
+      const res = sendTaskV2(null, {
+        agentId,
+        input,
+        timeoutMs: options.timeoutMs,
+      });
+      if (options.json) console.log(JSON.stringify(res, null, 2));
+      else logger.success(`Task ${res.taskId} submitted`);
+    });
+
+  a2a
+    .command("start-working")
+    .description("Transition a V2 task to working")
+    .argument("<taskId>", "Task ID")
+    .option("--json", "Output as JSON")
+    .action((taskId, options) => {
+      try {
+        const res = startWorking(null, taskId);
+        if (options.json) console.log(JSON.stringify(res, null, 2));
+        else logger.success(`Task ${taskId} → working`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  a2a
+    .command("request-input")
+    .description("Request user input while a V2 task is working")
+    .argument("<taskId>", "Task ID")
+    .argument("<prompt>", "Prompt to surface")
+    .option("--json", "Output as JSON")
+    .action((taskId, prompt, options) => {
+      try {
+        const res = requestInput(null, taskId, prompt);
+        if (options.json) console.log(JSON.stringify(res, null, 2));
+        else logger.success(`Task ${taskId} → input-required`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  a2a
+    .command("provide-input")
+    .description("Provide input for an input-required V2 task")
+    .argument("<taskId>", "Task ID")
+    .argument("<input>", "User-provided input")
+    .option("--json", "Output as JSON")
+    .action((taskId, input, options) => {
+      try {
+        const res = provideInput(null, taskId, input);
+        if (options.json) console.log(JSON.stringify(res, null, 2));
+        else logger.success(`Task ${taskId} → working`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  a2a
+    .command("complete-task-v2")
+    .description("Complete a V2 task (from working only)")
+    .argument("<taskId>", "Task ID")
+    .argument("[output]", "Task output", "")
+    .option("--json", "Output as JSON")
+    .action((taskId, output, options) => {
+      try {
+        const res = completeTaskV2(null, taskId, output);
+        if (options.json) console.log(JSON.stringify(res, null, 2));
+        else logger.success(`Task ${taskId} → completed`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  a2a
+    .command("fail-task-v2")
+    .description("Fail a V2 task with an error message")
+    .argument("<taskId>", "Task ID")
+    .argument("[error]", "Error message", "Unknown error")
+    .option("--json", "Output as JSON")
+    .action((taskId, error, options) => {
+      try {
+        const res = failTaskV2(null, taskId, error);
+        if (options.json) console.log(JSON.stringify(res, null, 2));
+        else logger.warn(`Task ${taskId} → failed`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  a2a
+    .command("cancel-task")
+    .description("Cancel a non-terminal V2 task")
+    .argument("<taskId>", "Task ID")
+    .argument("[reason]", "Cancel reason", "user_requested")
+    .option("--json", "Output as JSON")
+    .action((taskId, reason, options) => {
+      try {
+        const res = cancelTask(null, taskId, reason);
+        if (options.json) console.log(JSON.stringify(res, null, 2));
+        else logger.log(`Task ${taskId} → canceled`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  a2a
+    .command("check-timeout")
+    .description("Check V2 task timeout (auto-fails if past deadline)")
+    .argument("<taskId>", "Task ID")
+    .option("--json", "Output as JSON")
+    .action((taskId, options) => {
+      try {
+        const res = checkTaskTimeout(null, taskId);
+        if (options.json) console.log(JSON.stringify(res, null, 2));
+        else if (res.timedOut) logger.warn(`Task ${taskId} timed out`);
+        else logger.log(`Task ${taskId} status: ${res.status}`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  a2a
+    .command("task-v2")
+    .description("Show a V2 task snapshot")
+    .argument("<taskId>", "Task ID")
+    .option("--json", "Output as JSON")
+    .action((taskId, options) => {
+      try {
+        const task = getTaskV2(taskId);
+        if (options.json) console.log(JSON.stringify(task, null, 2));
+        else {
+          logger.log(`Task: ${task.taskId}`);
+          logger.log(`  Agent:    ${task.agentId}`);
+          logger.log(`  Status:   ${task.status}`);
+          logger.log(`  History:  ${task.history.length} entries`);
+          if (task.deadline)
+            logger.log(`  Deadline: ${new Date(task.deadline).toISOString()}`);
+          if (task.inputPrompt) logger.log(`  Prompt:   ${task.inputPrompt}`);
+          if (task.cancelReason) logger.log(`  Cancel:   ${task.cancelReason}`);
+        }
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  a2a
+    .command("tasks-v2")
+    .description("List V2 tasks")
+    .option("--agent-id <id>", "Filter by agent ID")
+    .option("--status <s>", "Filter by status")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const filter = {};
+      if (options.agentId) filter.agentId = options.agentId;
+      if (options.status) filter.status = options.status;
+      const tasks = listTasksV2(filter);
+      if (options.json) console.log(JSON.stringify(tasks, null, 2));
+      else {
+        if (!tasks.length) {
+          logger.log("No V2 tasks");
+          return;
+        }
+        tasks.forEach((t) => {
+          logger.log(
+            `  ${t.taskId}  [${t.status}]  agent=${t.agentId}  history=${t.history.length}`,
+          );
+        });
+      }
+    });
+
+  a2a
+    .command("negotiate-v2")
+    .description("Phase 81 capability negotiation against an agent card")
+    .argument("<cardJson>", "Agent card as JSON string")
+    .option("--required <csv>", "Required capabilities CSV", "")
+    .option("--preferred <csv>", "Preferred capabilities CSV", "")
+    .option("--client-version <semver>", "Client version")
+    .option("--json", "Output as JSON")
+    .action((cardJson, options) => {
+      let card;
+      try {
+        card = JSON.parse(cardJson);
+      } catch (_err) {
+        logger.error("cardJson must be valid JSON");
+        process.exit(1);
+      }
+      const result = negotiateCapabilityV2(card, {
+        required: options.required
+          ? options.required.split(",").map((s) => s.trim())
+          : [],
+        preferred: options.preferred
+          ? options.preferred.split(",").map((s) => s.trim())
+          : [],
+        version: options.clientVersion,
+      });
+      if (options.json) console.log(JSON.stringify(result, null, 2));
+      else {
+        logger.log(`Result: ${result.result}`);
+        if (result.missingRequired.length)
+          logger.log(
+            `  Missing required:  ${result.missingRequired.join(", ")}`,
+          );
+        if (result.missingPreferred.length)
+          logger.log(
+            `  Missing preferred: ${result.missingPreferred.join(", ")}`,
+          );
+        logger.log(`  Version OK:        ${result.versionOk}`);
+      }
+    });
+
+  a2a
+    .command("stats-v2")
+    .description("Aggregate V2 stats (tasks + cards + subscriptions)")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const s = getA2AStatsV2();
+      if (options.json) console.log(JSON.stringify(s, null, 2));
+      else {
+        logger.log("A2A V2 Stats:");
+        logger.log(`  Tasks total:     ${s.tasks.total}`);
+        logger.log(`  Tasks by status: ${JSON.stringify(s.tasks.byStatus)}`);
+        logger.log(`  With deadline:   ${s.tasks.withDeadline}`);
+        logger.log(`  Cards tracked:   ${s.cards.tracked}`);
+        logger.log(`  Subs (legacy):   ${s.subscriptions.legacy}`);
+        logger.log(`  Subs (typed):    ${s.subscriptions.typed}`);
+      }
+    });
 }

package/src/commands/agent-network.js

@@ -50,6 +50,37 @@ import {
   getTopAgents,
   getNetworkStats,
   getNetworkConfig,
+  AGENT_MATURITY_V2,
+  TASK_LIFECYCLE_V2,
+  getMaxActiveAgentsPerNetworkV2,
+  setMaxActiveAgentsPerNetworkV2,
+  getMaxPendingTasksPerAgentV2,
+  setMaxPendingTasksPerAgentV2,
+  getAgentIdleMsV2,
+  setAgentIdleMsV2,
+  getTaskStuckMsV2,
+  setTaskStuckMsV2,
+  registerAgentV2,
+  getAgentV2,
+  listAgentsV2,
+  setAgentStatusV2,
+  activateAgentV2,
+  suspendAgentV2,
+  revokeAgentV2,
+  touchAgentV2,
+  createTaskV2,
+  getTaskV2,
+  listTasksV2,
+  setTaskStatusV2,
+  startTaskV2,
+  completeTaskV2,
+  failTaskV2,
+  cancelTaskV2,
+  getActiveAgentCountV2,
+  getPendingTaskCountV2,
+  autoSuspendIdleAgentsV2,
+  autoFailStuckTasksV2,
+  getAgentNetworkStatsV2,
 } from "../lib/agent-network.js";
 
 function _dbFromCtx(cmd) {
@@ -81,7 +112,8 @@ export function registerAgentNetworkCommand(program) {
     .description(
       "Decentralized Agent Network (Phase 24) — DID / registry / credentials / task routing",
     )
-    .hook("preAction", (thisCmd) => {
+    .hook("preAction", (thisCmd, actionCommand) => {
+      if (actionCommand && actionCommand.name().endsWith("-v2")) return;
       const db = _dbFromCtx(thisCmd);
       if (db) ensureAgentNetworkTables(db);
     });
@@ -780,6 +812,227 @@ export function registerAgentNetworkCommand(program) {
       console.log(`Peers: ${s.peers}`);
     });
 
+  // ─── V2 Governance Layer ──────────────────────────────────────────
+  const out = (obj) => console.log(JSON.stringify(obj, null, 2));
+  const tryRun = (fn) => {
+    try {
+      fn();
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  };
+
+  anet
+    .command("agent-maturities-v2")
+    .description("List V2 agent maturity states")
+    .action(() => out(Object.values(AGENT_MATURITY_V2)));
+
+  anet
+    .command("task-lifecycles-v2")
+    .description("List V2 task lifecycle states")
+    .action(() => out(Object.values(TASK_LIFECYCLE_V2)));
+
+  anet
+    .command("stats-v2")
+    .description("V2 agent-network stats")
+    .action(() => out(getAgentNetworkStatsV2()));
+
+  anet
+    .command("get-max-active-agents-v2")
+    .description("Get max active agents per network (V2)")
+    .action(() =>
+      out({ maxActiveAgentsPerNetwork: getMaxActiveAgentsPerNetworkV2() }),
+    );
+
+  anet
+    .command("set-max-active-agents-v2 <n>")
+    .description("Set max active agents per network (V2)")
+    .action((n) =>
+      tryRun(() => {
+        setMaxActiveAgentsPerNetworkV2(Number(n));
+        out({ maxActiveAgentsPerNetwork: getMaxActiveAgentsPerNetworkV2() });
+      }),
+    );
+
+  anet
+    .command("get-max-pending-tasks-v2")
+    .description("Get max pending tasks per agent (V2)")
+    .action(() =>
+      out({ maxPendingTasksPerAgent: getMaxPendingTasksPerAgentV2() }),
+    );
+
+  anet
+    .command("set-max-pending-tasks-v2 <n>")
+    .description("Set max pending tasks per agent (V2)")
+    .action((n) =>
+      tryRun(() => {
+        setMaxPendingTasksPerAgentV2(Number(n));
+        out({ maxPendingTasksPerAgent: getMaxPendingTasksPerAgentV2() });
+      }),
+    );
+
+  anet
+    .command("get-agent-idle-ms-v2")
+    .description("Get agent idle threshold (V2)")
+    .action(() => out({ agentIdleMs: getAgentIdleMsV2() }));
+
+  anet
+    .command("set-agent-idle-ms-v2 <ms>")
+    .description("Set agent idle threshold (V2)")
+    .action((ms) =>
+      tryRun(() => {
+        setAgentIdleMsV2(Number(ms));
+        out({ agentIdleMs: getAgentIdleMsV2() });
+      }),
+    );
+
+  anet
+    .command("get-task-stuck-ms-v2")
+    .description("Get task stuck threshold (V2)")
+    .action(() => out({ taskStuckMs: getTaskStuckMsV2() }));
+
+  anet
+    .command("set-task-stuck-ms-v2 <ms>")
+    .description("Set task stuck threshold (V2)")
+    .action((ms) =>
+      tryRun(() => {
+        setTaskStuckMsV2(Number(ms));
+        out({ taskStuckMs: getTaskStuckMsV2() });
+      }),
+    );
+
+  anet
+    .command("active-agent-count-v2 <networkId>")
+    .description("Active agent count for network (V2)")
+    .action((networkId) =>
+      out({ networkId, count: getActiveAgentCountV2(networkId) }),
+    );
+
+  anet
+    .command("pending-task-count-v2 <agentId>")
+    .description("Pending task count for agent (V2)")
+    .action((agentId) =>
+      out({ agentId, count: getPendingTaskCountV2(agentId) }),
+    );
+
+  anet
+    .command("register-agent-v2 <id>")
+    .description("Register a V2 agent")
+    .requiredOption("-n, --network <id>", "network id")
+    .requiredOption("-d, --did <did>", "agent DID")
+    .option("--display <name>", "display name")
+    .action((id, opts) =>
+      tryRun(() =>
+        out(
+          registerAgentV2(id, {
+            networkId: opts.network,
+            did: opts.did,
+            displayName: opts.display,
+          }),
+        ),
+      ),
+    );
+
+  anet
+    .command("get-agent-v2 <id>")
+    .description("Get a V2 agent")
+    .action((id) => out(getAgentV2(id)));
+
+  anet
+    .command("list-agents-v2")
+    .description("List V2 agents")
+    .option("-n, --network <id>", "filter by network")
+    .option("-s, --status <status>", "filter by status")
+    .action((opts) =>
+      out(listAgentsV2({ networkId: opts.network, status: opts.status })),
+    );
+
+  anet
+    .command("set-agent-status-v2 <id> <next>")
+    .description("Set V2 agent status")
+    .action((id, next) => tryRun(() => out(setAgentStatusV2(id, next))));
+
+  anet
+    .command("activate-agent-v2 <id>")
+    .description("Activate a V2 agent")
+    .action((id) => tryRun(() => out(activateAgentV2(id))));
+
+  anet
+    .command("suspend-agent-v2 <id>")
+    .description("Suspend a V2 agent")
+    .action((id) => tryRun(() => out(suspendAgentV2(id))));
+
+  anet
+    .command("revoke-agent-v2 <id>")
+    .description("Revoke a V2 agent")
+    .action((id) => tryRun(() => out(revokeAgentV2(id))));
+
+  anet
+    .command("touch-agent-v2 <id>")
+    .description("Touch a V2 agent")
+    .action((id) => tryRun(() => out(touchAgentV2(id))));
+
+  anet
+    .command("create-task-v2 <id>")
+    .description("Create a V2 task")
+    .requiredOption("-a, --agent <id>", "agent id")
+    .option("-k, --kind <kind>", "task kind", "invoke")
+    .action((id, opts) =>
+      tryRun(() =>
+        out(createTaskV2(id, { agentId: opts.agent, kind: opts.kind })),
+      ),
+    );
+
+  anet
+    .command("get-task-v2 <id>")
+    .description("Get a V2 task")
+    .action((id) => out(getTaskV2(id)));
+
+  anet
+    .command("list-tasks-v2")
+    .description("List V2 tasks")
+    .option("-a, --agent <id>", "filter by agent")
+    .option("-s, --status <status>", "filter by status")
+    .action((opts) =>
+      out(listTasksV2({ agentId: opts.agent, status: opts.status })),
+    );
+
+  anet
+    .command("set-task-status-v2 <id> <next>")
+    .description("Set V2 task status")
+    .action((id, next) => tryRun(() => out(setTaskStatusV2(id, next))));
+
+  anet
+    .command("start-task-v2 <id>")
+    .description("Start a V2 task")
+    .action((id) => tryRun(() => out(startTaskV2(id))));
+
+  anet
+    .command("complete-task-v2 <id>")
+    .description("Complete a V2 task")
+    .action((id) => tryRun(() => out(completeTaskV2(id))));
+
+  anet
+    .command("fail-task-v2 <id>")
+    .description("Fail a V2 task")
+    .action((id) => tryRun(() => out(failTaskV2(id))));
+
+  anet
+    .command("cancel-task-v2 <id>")
+    .description("Cancel a V2 task")
+    .action((id) => tryRun(() => out(cancelTaskV2(id))));
+
+  anet
+    .command("auto-suspend-idle-agents-v2")
+    .description("Auto-suspend idle V2 agents")
+    .action(() => out(autoSuspendIdleAgentsV2()));
+
+  anet
+    .command("auto-fail-stuck-tasks-v2")
+    .description("Auto-fail stuck V2 tasks")
+    .action(() => out(autoFailStuckTasksV2()));
+
   program.addCommand(anet);
   return anet;
 }