chainlesschain 0.37.9 → 0.37.11

package/src/commands/a2a.js

@@ -0,0 +1,374 @@
+/**
+ * A2A (Agent-to-Agent) Protocol commands
+ * chainlesschain a2a register|discover|submit|status|complete|fail|peers|cards|negotiate
+ */
+
+import chalk from "chalk";
+import ora from "ora";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  registerCard,
+  updateCard,
+  discoverAgents,
+  sendTask,
+  completeTask,
+  failTask,
+  getTaskStatus,
+  negotiateCapability,
+  listPeers,
+} from "../lib/a2a-protocol.js";
+
+export function registerA2aCommand(program) {
+  const a2a = program
+    .command("a2a")
+    .description("A2A Protocol — agent-to-agent communication");
+
+  // a2a register <name>
+  a2a
+    .command("register")
+    .description("Register an agent card")
+    .argument("<name>", "Agent name")
+    .option("--description <desc>", "Agent description", "")
+    .option("--url <url>", "Agent endpoint URL", "")
+    .option("--capabilities <csv>", "Comma-separated capabilities", "")
+    .option("--skills <csv>", "Comma-separated skills", "")
+    .option("--json", "Output as JSON")
+    .action(async (name, 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 card = registerCard(db, {
+          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.json) {
+          console.log(JSON.stringify(card, null, 2));
+        } else {
+          logger.success(
+            `Agent registered: ${chalk.cyan(card.name)} ${chalk.gray(card.id)}`,
+          );
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // a2a discover
+  a2a
+    .command("discover")
+    .description("Discover agents by capability or skill")
+    .option("--capability <name>", "Filter by capability")
+    .option("--skill <name>", "Filter by skill")
+    .option("--name <filter>", "Filter by name")
+    .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();
+        const agents = discoverAgents(db, {
+          capability: options.capability,
+          skill: options.skill,
+          name: options.name,
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(agents, null, 2));
+        } else if (agents.length === 0) {
+          logger.info("No agents found matching criteria");
+        } else {
+          logger.log(chalk.bold(`Discovered ${agents.length} agents:\n`));
+          for (const a of agents) {
+            logger.log(`  ${chalk.cyan(a.name)} ${chalk.gray(a.id)}`);
+            if (a.description) logger.log(`    ${chalk.white(a.description)}`);
+            if (a.capabilities.length)
+              logger.log(
+                `    Capabilities: ${chalk.yellow(a.capabilities.join(", "))}`,
+              );
+            if (a.skills.length)
+              logger.log(`    Skills: ${chalk.yellow(a.skills.join(", "))}`);
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // a2a submit <agent-id> <input>
+  a2a
+    .command("submit")
+    .description("Submit a task to an agent")
+    .argument("<agent-id>", "Target agent ID")
+    .argument("<input>", "Task input")
+    .option("--json", "Output as JSON")
+    .action(async (agentId, input, 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 result = sendTask(db, agentId, input);
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.success(
+            `Task submitted: ${chalk.gray(result.taskId)} [${chalk.yellow(result.status)}]`,
+          );
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // a2a status <task-id>
+  a2a
+    .command("status")
+    .description("Get task status")
+    .argument("<task-id>", "Task ID")
+    .option("--json", "Output as JSON")
+    .action(async (taskId, 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 task = getTaskStatus(db, taskId);
+
+        if (options.json) {
+          console.log(JSON.stringify(task, null, 2));
+        } else {
+          logger.log(chalk.bold("Task Status:\n"));
+          logger.log(`  ID:     ${chalk.gray(task.id)}`);
+          logger.log(`  Agent:  ${chalk.cyan(task.agent_id)}`);
+          logger.log(`  Status: ${chalk.yellow(task.status)}`);
+          if (task.input)
+            logger.log(
+              `  Input:  ${chalk.white(task.input.substring(0, 100))}`,
+            );
+          if (task.output)
+            logger.log(
+              `  Output: ${chalk.green(task.output.substring(0, 100))}`,
+            );
+          if (task.error) logger.log(`  Error:  ${chalk.red(task.error)}`);
+          if (task.history.length) {
+            logger.log("  History:");
+            for (const h of task.history) {
+              logger.log(
+                `    ${chalk.gray(h.timestamp)} → ${chalk.yellow(h.status)}`,
+              );
+            }
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // a2a complete <task-id> <output>
+  a2a
+    .command("complete")
+    .description("Mark a task as completed")
+    .argument("<task-id>", "Task ID")
+    .argument("<output>", "Task output")
+    .action(async (taskId, output) => {
+      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 = completeTask(db, taskId, output);
+        logger.success(
+          `Task ${chalk.gray(taskId)} → ${chalk.green(result.status)}`,
+        );
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // a2a fail <task-id> <error>
+  a2a
+    .command("fail")
+    .description("Mark a task as failed")
+    .argument("<task-id>", "Task ID")
+    .argument("<error>", "Error message")
+    .action(async (taskId, error) => {
+      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 = failTask(db, taskId, error);
+        logger.success(
+          `Task ${chalk.gray(taskId)} → ${chalk.red(result.status)}`,
+        );
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // a2a peers
+  a2a
+    .command("peers")
+    .description("List all registered agents")
+    .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();
+        const peers = listPeers(db);
+
+        if (options.json) {
+          console.log(JSON.stringify(peers, null, 2));
+        } else if (peers.length === 0) {
+          logger.info("No agents registered. Use 'a2a register' to add one.");
+        } else {
+          logger.log(chalk.bold(`${peers.length} registered agents:\n`));
+          for (const p of peers) {
+            const statusColor =
+              p.status === "active" ? chalk.green : chalk.gray;
+            logger.log(
+              `  ${chalk.cyan(p.name)} ${chalk.gray(p.id)} ${statusColor(p.status)}`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // a2a cards
+  a2a
+    .command("cards")
+    .description("List all agent cards with details")
+    .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();
+        const peers = listPeers(db);
+
+        if (options.json) {
+          console.log(JSON.stringify(peers, null, 2));
+        } else if (peers.length === 0) {
+          logger.info("No agent cards registered.");
+        } else {
+          logger.log(chalk.bold(`${peers.length} agent cards:\n`));
+          for (const p of peers) {
+            logger.log(`  ${chalk.cyan(p.name)} ${chalk.gray(p.id)}`);
+            if (p.description) logger.log(`    Description: ${p.description}`);
+            if (p.url) logger.log(`    URL: ${chalk.blue(p.url)}`);
+            logger.log(`    Auth: ${p.auth_type}`);
+            if (p.capabilities.length)
+              logger.log(
+                `    Capabilities: ${chalk.yellow(p.capabilities.join(", "))}`,
+              );
+            if (p.skills.length)
+              logger.log(`    Skills: ${chalk.yellow(p.skills.join(", "))}`);
+            logger.log("");
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // a2a negotiate <agent-id> <capabilities>
+  a2a
+    .command("negotiate")
+    .description("Check if an agent supports required capabilities")
+    .argument("<agent-id>", "Agent ID")
+    .argument("<capabilities>", "Comma-separated required capabilities")
+    .option("--json", "Output as JSON")
+    .action(async (agentId, capabilities, 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 required = capabilities.split(",").map((s) => s.trim());
+        const result = negotiateCapability(db, agentId, required);
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          if (result.compatible) {
+            logger.success("Agent is fully compatible");
+          } else {
+            logger.warn("Agent is not fully compatible");
+          }
+          if (result.supported.length) {
+            logger.log(
+              `  Supported: ${chalk.green(result.supported.join(", "))}`,
+            );
+          }
+          if (result.missing.length) {
+            logger.log(`  Missing:   ${chalk.red(result.missing.join(", "))}`);
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/audit.js

@@ -0,0 +1,286 @@
+/**
+ * Audit log commands
+ * chainlesschain audit log|search|stats|export|purge
+ */
+
+import chalk from "chalk";
+import fs from "fs";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  getRecentEvents,
+  queryLogs,
+  getStatistics,
+  exportLogs,
+  purgeLogs,
+  EVENT_TYPES,
+  RISK_LEVELS,
+} from "../lib/audit-logger.js";
+
+const RISK_COLORS = {
+  low: chalk.gray,
+  medium: chalk.yellow,
+  high: chalk.red,
+  critical: chalk.bgRed.white,
+};
+
+function formatLogEntry(log) {
+  const riskColor = RISK_COLORS[log.risk_level] || chalk.gray;
+  const status = log.success ? chalk.green("OK") : chalk.red("FAIL");
+  const time = log.created_at || "";
+
+  return [
+    `  ${chalk.gray(log.id.slice(0, 8))} ${chalk.gray(time)}`,
+    `    ${chalk.cyan(log.event_type.padEnd(12))} ${chalk.white(log.operation)} ${status} ${riskColor(`[${log.risk_level}]`)}`,
+    log.actor ? `    ${chalk.gray("actor:")} ${log.actor}` : null,
+    log.target ? `    ${chalk.gray("target:")} ${log.target}` : null,
+    log.error_message
+      ? `    ${chalk.red("error:")} ${log.error_message}`
+      : null,
+  ]
+    .filter(Boolean)
+    .join("\n");
+}
+
+export function registerAuditCommand(program) {
+  const audit = program
+    .command("audit")
+    .description("Audit log — security event tracking and compliance");
+
+  // audit log (default)
+  audit
+    .command("log", { isDefault: true })
+    .description("Show recent audit events")
+    .option("-n, --limit <n>", "Number of events to show", "20")
+    .option("--type <type>", "Filter by event type")
+    .option("--risk <level>", "Filter by risk level")
+    .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();
+
+        const filters = {
+          limit: parseInt(options.limit) || 20,
+        };
+        if (options.type) filters.eventType = options.type;
+        if (options.risk) filters.riskLevel = options.risk;
+
+        const logs = queryLogs(db, filters);
+
+        if (options.json) {
+          console.log(JSON.stringify(logs, null, 2));
+        } else if (logs.length === 0) {
+          logger.info("No audit events found");
+        } else {
+          logger.log(chalk.bold(`Audit Log (${logs.length} events):\n`));
+          for (const log of logs) {
+            logger.log(formatLogEntry(log));
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // audit search
+  audit
+    .command("search")
+    .description("Search audit logs")
+    .argument("<query>", "Search query")
+    .option("-n, --limit <n>", "Max results", "50")
+    .option("--type <type>", "Filter by event type")
+    .option("--risk <level>", "Filter by risk level")
+    .option("--from <date>", "Start date (ISO 8601)")
+    .option("--to <date>", "End date (ISO 8601)")
+    .option("--failures", "Show only failed events")
+    .option("--json", "Output as JSON")
+    .action(async (query, 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 filters = {
+          search: query,
+          limit: parseInt(options.limit) || 50,
+        };
+        if (options.type) filters.eventType = options.type;
+        if (options.risk) filters.riskLevel = options.risk;
+        if (options.from) filters.startDate = options.from;
+        if (options.to) filters.endDate = options.to;
+        if (options.failures) filters.success = false;
+
+        const logs = queryLogs(db, filters);
+
+        if (options.json) {
+          console.log(JSON.stringify(logs, null, 2));
+        } else if (logs.length === 0) {
+          logger.info(`No audit events matching "${query}"`);
+        } else {
+          logger.log(chalk.bold(`Search Results (${logs.length}):\n`));
+          for (const log of logs) {
+            logger.log(formatLogEntry(log));
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // audit stats
+  audit
+    .command("stats")
+    .description("Show audit statistics")
+    .option("--from <date>", "Start date")
+    .option("--to <date>", "End date")
+    .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();
+        const stats = getStatistics(db, options.from, options.to);
+
+        if (options.json) {
+          console.log(JSON.stringify(stats, null, 2));
+        } else {
+          logger.log(chalk.bold("Audit Statistics:\n"));
+          logger.log(`  ${chalk.bold("Total events:")}   ${stats.total}`);
+          logger.log(
+            `  ${chalk.bold("Failures:")}       ${chalk.red(stats.failures)}`,
+          );
+          logger.log(
+            `  ${chalk.bold("High risk:")}      ${chalk.red(stats.highRisk)}`,
+          );
+
+          if (Object.keys(stats.byEventType).length > 0) {
+            logger.log(`\n  ${chalk.bold("By Event Type:")}`);
+            for (const [type, count] of Object.entries(stats.byEventType)) {
+              logger.log(`    ${chalk.cyan(type.padEnd(15))} ${count}`);
+            }
+          }
+
+          if (Object.keys(stats.byRiskLevel).length > 0) {
+            logger.log(`\n  ${chalk.bold("By Risk Level:")}`);
+            for (const [level, count] of Object.entries(stats.byRiskLevel)) {
+              const color = RISK_COLORS[level] || chalk.gray;
+              logger.log(`    ${color(level.padEnd(15))} ${count}`);
+            }
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // audit export
+  audit
+    .command("export")
+    .description("Export audit logs to file")
+    .option("-o, --output <path>", "Output file path")
+    .option("-f, --format <fmt>", "Format: json or csv", "json")
+    .option("--from <date>", "Start date")
+    .option("--to <date>", "End date")
+    .option("-n, --limit <n>", "Max events", "10000")
+    .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();
+
+        const filters = { limit: parseInt(options.limit) || 10000 };
+        if (options.from) filters.startDate = options.from;
+        if (options.to) filters.endDate = options.to;
+
+        const data = exportLogs(db, options.format, filters);
+
+        if (options.output) {
+          fs.writeFileSync(options.output, data, "utf8");
+          logger.success(`Exported to ${options.output}`);
+        } else {
+          console.log(data);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // audit purge
+  audit
+    .command("purge")
+    .description("Delete old audit logs")
+    .option("--days <n>", "Keep logs from last N days", "90")
+    .option("--force", "Skip confirmation")
+    .action(async (options) => {
+      try {
+        const days = parseInt(options.days) || 90;
+
+        if (!options.force) {
+          const { confirm } = await import("@inquirer/prompts");
+          const ok = await confirm({
+            message: `Delete audit logs older than ${days} days? This cannot be undone.`,
+          });
+          if (!ok) {
+            logger.info("Cancelled");
+            return;
+          }
+        }
+
+        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 deleted = purgeLogs(db, days);
+        logger.success(`Purged ${deleted} old audit events`);
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // audit types
+  audit
+    .command("types")
+    .description("List available event types and risk levels")
+    .action(async () => {
+      logger.log(chalk.bold("Event Types:\n"));
+      for (const [key, value] of Object.entries(EVENT_TYPES)) {
+        logger.log(`  ${chalk.cyan(value.padEnd(15))} ${chalk.gray(key)}`);
+      }
+      logger.log(chalk.bold("\nRisk Levels:\n"));
+      for (const [key, value] of Object.entries(RISK_LEVELS)) {
+        const color = RISK_COLORS[value] || chalk.gray;
+        logger.log(`  ${color(value.padEnd(15))} ${chalk.gray(key)}`);
+      }
+    });
+}