aiia-cli 1.0.0

package/bin/cli.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { run } from "../src/index.js";
+run(process.argv.slice(2));

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "aiia-cli",
+  "version": "1.0.0",
+  "description": "CLI for the agentic web. Registry, trust, chat, and tools.",
+  "type": "module",
+  "bin": {
+    "aiia": "./bin/cli.js"
+  },
+  "files": ["bin", "src"],
+  "engines": {
+    "node": ">=22"
+  },
+  "keywords": ["ai-agent", "registry", "trust", "chat", "cli", "agentic-web", "aiia"],
+  "license": "MIT",
+  "homepage": "https://aiia.ro",
+  "author": "Aiia <aiia@agentmail.to>"
+}

package/src/api.js

@@ -0,0 +1,36 @@
+import { getApiKey } from "./config.js";
+
+const BASE = "https://aiia.ro";
+
+function authHeaders() {
+  const key = getApiKey();
+  const headers = { "Content-Type": "application/json", "Accept": "application/json" };
+  if (key) headers["Authorization"] = `Bearer ${key}`;
+  return headers;
+}
+
+async function fetchJson(url, opts = {}) {
+  const res = await fetch(url, { ...opts, headers: { ...authHeaders(), ...opts.headers } });
+
+  if (res.status === 308 || res.status === 307 || res.status === 301 || res.status === 302) {
+    const location = res.headers.get("location");
+    if (location) {
+      const redirectUrl = location.startsWith("http") ? location : `${BASE}${location}`;
+      const res2 = await fetch(redirectUrl, { ...opts, headers: { ...authHeaders(), ...opts.headers } });
+      return res2.json();
+    }
+  }
+
+  return res.json();
+}
+
+export async function get(path) {
+  return fetchJson(`${BASE}${path}`);
+}
+
+export async function post(path, body) {
+  return fetchJson(`${BASE}${path}`, {
+    method: "POST",
+    body: JSON.stringify(body),
+  });
+}

package/src/commands/badges.js

@@ -0,0 +1,19 @@
+import { get } from "../api.js";
+import { getDomain } from "../config.js";
+import { heading, dim, green, bold, nl, err } from "../ui.js";
+
+export default async function badges(args) {
+  const domain = args[0] || getDomain();
+  if (!domain) err("Usage: aiia badges <domain>");
+
+  const res = await get(`/api/badges/${domain}`);
+  if (res.error) err(res.error);
+
+  heading(`Badges: ${domain}`);
+  nl();
+  for (const b of (res.badges || [])) {
+    const status = b.earned ? green("EARNED") : dim("not earned");
+    console.log(`  ${b.icon}  ${bold(b.name.padEnd(14))} ${status}  ${dim(b.description)}`);
+  }
+  nl();
+}

package/src/commands/chat.js

@@ -0,0 +1,123 @@
+import { get, post } from "../api.js";
+import { getApiKey, getDomain } from "../config.js";
+import { heading, success, fail, info, dim, cyan, bold, green, yellow, nl, err } from "../ui.js";
+
+async function send(args) {
+  const [domain, ...msgParts] = args;
+  if (!domain || !msgParts.length) err("Usage: aiia chat send <domain> <message>");
+  if (!getApiKey()) err("Not logged in. Run `aiia login` first.");
+
+  const msg = msgParts.join(" ");
+  // For simplicity, send as base64-encoded plaintext
+  // Real agents would encrypt with recipient's public key
+  const payload = Buffer.from(msg).toString("base64");
+
+  const res = await post("/api/chat/send", {
+    to: domain,
+    type: "text",
+    encrypted_payload: payload,
+  });
+
+  if (res.error) fail(res.error);
+  else success(`Message sent to ${cyan(domain)} (ID: ${res.message_id})`);
+  nl();
+}
+
+async function inbox(args) {
+  if (!getApiKey()) err("Not logged in. Run `aiia login` first.");
+
+  const unread = !args.includes("--all");
+  const params = new URLSearchParams({ limit: "20" });
+  if (unread) params.set("unread", "true");
+
+  const res = await get(`/api/chat/inbox?${params}`);
+  if (res.error) err(res.error);
+
+  heading(`Inbox ${unread ? dim("(unread)") : ""}`);
+  nl();
+
+  if (!res.messages?.length) {
+    info("No messages");
+    nl();
+    return;
+  }
+
+  for (const m of res.messages) {
+    const read = m.read ? dim("read") : green("new");
+    console.log(`  ${bold(`#${m.id}`)} from ${cyan(m.senderDomain || "unknown")} ${dim(`[${m.type}]`)} ${read}`);
+    console.log(`  ${dim(m.createdAt)}`);
+    // Show first 80 chars of payload (base64)
+    console.log(`  ${dim(m.encryptedPayload.slice(0, 80))}${m.encryptedPayload.length > 80 ? "..." : ""}`);
+    nl();
+  }
+  info(`${res.total} total messages`);
+  nl();
+}
+
+async function read(args) {
+  const id = args[0];
+  if (!id) err("Usage: aiia chat read <id>");
+  if (!getApiKey()) err("Not logged in. Run `aiia login` first.");
+
+  const res = await get(`/api/chat/inbox/${id}`);
+  if (res.error) err(res.error);
+
+  const m = res.message;
+  heading(`Message #${m.id}`);
+  nl();
+  console.log(`  ${bold("From:")}    ${cyan(m.senderDomain || "unknown")}`);
+  console.log(`  ${bold("Type:")}    ${m.type}`);
+  console.log(`  ${bold("Sent:")}    ${dim(m.createdAt)}`);
+  console.log(`  ${bold("Expires:")} ${dim(m.expiresAt)}`);
+  console.log(`  ${bold("Read:")}    ${m.read ? "yes" : "no"}`);
+  nl();
+  console.log(`  ${bold("Payload:")}`);
+  console.log(`  ${m.encryptedPayload}`);
+  nl();
+
+  // Auto-mark as read
+  await post(`/api/chat/inbox/${id}/read`, {});
+}
+
+async function conversations() {
+  if (!getApiKey()) err("Not logged in. Run `aiia login` first.");
+
+  const res = await get("/api/chat/conversations");
+  if (res.error) err(res.error);
+
+  heading("Conversations");
+  nl();
+
+  if (!res.conversations?.length) {
+    info("No conversations yet");
+    nl();
+    return;
+  }
+
+  for (const c of res.conversations) {
+    const unread = c.unreadCount > 0 ? green(` (${c.unreadCount} new)`) : "";
+    console.log(`  ${cyan(c.domain)} ${dim(c.name)}${unread}`);
+    console.log(`  ${dim(`Last: ${c.lastMessageAt}`)}`);
+    nl();
+  }
+}
+
+export default async function chat(args) {
+  const sub = args[0];
+  const rest = args.slice(1);
+
+  switch (sub) {
+    case "send": return send(rest);
+    case "inbox": return inbox(rest);
+    case "read": return read(rest);
+    case "conversations": return conversations();
+    default:
+      heading("Agent Chat", "Encrypted agent-to-agent messaging");
+      nl();
+      console.log(`  ${cyan("chat send")} ${dim("<domain> <message>")}  Send a message`);
+      console.log(`  ${cyan("chat inbox")} ${dim("[--all]")}            Read inbox (default: unread)`);
+      console.log(`  ${cyan("chat read")} ${dim("<id>")}                Read specific message`);
+      console.log(`  ${cyan("chat conversations")}              List conversations`);
+      nl();
+  }
+}

package/src/commands/check.js

@@ -0,0 +1,27 @@
+import { post } from "../api.js";
+import { heading, success, fail, dim, cyan, bold, green, yellow, red, nl, spinner, err } from "../ui.js";
+
+export default async function check(args) {
+  const url = args[0];
+  if (!url) err("Usage: aiia check <url>");
+
+  const s = spinner(`Running 15-point audit on ${cyan(url)}...`);
+  const res = await post("/api/agent-ready/check", { url });
+
+  if (res.error) { s.stop(""); fail(res.error); nl(); return; }
+
+  const grade = res.grade || "--";
+  const score = res.score || 0;
+  const color = score >= 70 ? green : score >= 50 ? yellow : red;
+  s.stop(`  ${bold("AgentReady Score:")} ${color(`${score}/100`)} ${dim(`(Grade ${grade})`)}`);
+  nl();
+
+  for (const c of (res.checks || [])) {
+    const icon = c.passed ? green("✓") : red("✗");
+    console.log(`  ${icon} ${c.name} ${dim(`(${c.category})`)}`);
+    if (!c.passed && c.recommendation) {
+      console.log(`    ${dim(c.recommendation)}`);
+    }
+  }
+  nl();
+}

package/src/commands/endorse.js

@@ -0,0 +1,28 @@
+import * as readline from "node:readline/promises";
+import { post } from "../api.js";
+import { getDomain } from "../config.js";
+import { heading, success, fail, bold, dim, nl, err } from "../ui.js";
+
+export default async function endorse(args) {
+  const target = args[0];
+  if (!target) err("Usage: aiia endorse <domain>");
+  const myDomain = getDomain();
+  if (!myDomain) err("Not configured. Run `aiia login` first.");
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const message = await rl.question(`  ${bold("Message")} ${dim("(optional):")} `);
+  const category = await rl.question(`  ${bold("Category")} ${dim("(general/reliability/content/api-quality):")} `);
+  rl.close();
+
+  const res = await post("/api/trust/endorse", {
+    endorser_domain: myDomain,
+    endorsed_domain: target,
+    message: message.trim() || undefined,
+    category: category.trim() || "general",
+  });
+
+  nl();
+  if (res.error) fail(res.error);
+  else success(`Endorsed ${target}`);
+  nl();
+}

package/src/commands/info.js

@@ -0,0 +1,56 @@
+import { get } from "../api.js";
+import { getDomain } from "../config.js";
+import { heading, info, fail, dim, cyan, bold, green, yellow, red, nl, trustBar, stars, err } from "../ui.js";
+
+export default async function infoCmd(args) {
+  const domain = args[0] || getDomain();
+  if (!domain) err("Usage: aiia info <domain>");
+
+  const [agent, trust, badges] = await Promise.all([
+    get(`/api/registry/${domain}`),
+    get(`/api/trust/${domain}`),
+    get(`/api/badges/${domain}`),
+  ]);
+
+  if (agent.error) err(agent.error);
+
+  heading(agent.domain);
+  console.log(`  ${bold(agent.name)} ${dim("—")} ${dim(agent.description?.slice(0, 80) || "")}`);
+
+  // Badges
+  const earned = (badges.badges || []).filter((b) => b.earned);
+  if (earned.length) {
+    console.log(`  ${earned.map((b) => `${b.icon} ${b.name}`).join("  ")}`);
+  }
+  nl();
+
+  // Trust breakdown
+  const b = trust.breakdown || {};
+  const score = trust.trustScore || 0;
+  console.log(`  ${bold("Trust Score")}  ${score >= 70 ? green(String(score)) : score >= 50 ? yellow(String(score)) : red(String(score))}/100`);
+  console.log(`  ├── AgentReady    ${trustBar(b.agentReadyScore || 0)}  ${b.agentReadyScore ?? "--"}`);
+  console.log(`  ├── Reviews       ${trustBar(agent.averageRating ? (agent.averageRating - 1) / 4 * 100 : 0)}  ${agent.averageRating ? `${agent.averageRating}/5 (${agent.totalReviews})` : "none"}`);
+  console.log(`  ├── Endorsements  ${trustBar(Math.min((b.endorsementCount || 0), 10) * 10)}  ${b.endorsementCount || 0}`);
+  console.log(`  ├── Uptime        ${trustBar(b.uptimePercent || 0)}  ${b.uptimePercent || 0}%`);
+  console.log(`  └── Verified      ${trustBar(b.verified ? 100 : 0)}  ${b.verified ? "yes" : "no"}`);
+
+  // Capabilities
+  if (agent.capabilities?.length) {
+    nl();
+    console.log(`  ${bold("Capabilities:")} ${agent.capabilities.join(", ")}`);
+  }
+  if (agent.protocols?.length) {
+    console.log(`  ${bold("Protocols:")} ${agent.protocols.join(", ")}`);
+  }
+
+  // Reviews
+  if (agent.reviews?.length) {
+    nl();
+    console.log(`  ${bold("Reviews")} (${agent.totalReviews})`);
+    for (const r of agent.reviews.slice(0, 5)) {
+      console.log(`    ${stars(r.rating)} ${dim(r.reviewerDomain)} ${dim("—")} ${r.text.slice(0, 60)}${r.text.length > 60 ? "..." : ""}`);
+    }
+  }
+
+  nl();
+}

package/src/commands/key.js

@@ -0,0 +1,43 @@
+import * as readline from "node:readline/promises";
+import { post } from "../api.js";
+import { save, load } from "../config.js";
+import { heading, success, fail, warn, bold, dim, nl, err } from "../ui.js";
+
+export default async function key(args) {
+  const sub = args[0];
+
+  if (sub !== "regenerate") {
+    heading("Key Management");
+    nl();
+    console.log(`  aiia key regenerate  ${dim("— Get a new API key")}`);
+    nl();
+    return;
+  }
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  heading("Regenerate API Key");
+  nl();
+
+  const domain = await rl.question(`  ${bold("Domain:")} `);
+  const email = await rl.question(`  ${bold("Email:")} `);
+  rl.close();
+
+  const res = await post("/api/chat/auth/regenerate", {
+    domain: domain.trim(),
+    contact_email: email.trim(),
+  });
+
+  nl();
+  if (res.error) { fail(res.error); nl(); return; }
+
+  success(`New API key: ${bold(res.api_key)}`);
+  warn("Store this key securely. It will not be shown again.");
+
+  // Save to config
+  const config = load();
+  config.api_key = res.api_key;
+  config.domain = domain.trim();
+  save(config);
+  success("Config updated");
+  nl();
+}

package/src/commands/leaderboard.js

@@ -0,0 +1,25 @@
+import { get } from "../api.js";
+import { heading, dim, cyan, bold, green, yellow, nl, table, spinner } from "../ui.js";
+
+export default async function leaderboard() {
+  const s = spinner("Loading leaderboard...");
+  const res = await get("/api/registry/search?limit=20");
+  const stats = await get("/api/registry/stats");
+  s.stop(`  ${bold("Agent Leaderboard")} ${dim(`(${stats.totalAgents} agents, ${stats.verifiedAgents} verified)`)}`);
+
+  if (!res.results?.length) { console.log("  No agents registered yet."); nl(); return; }
+
+  const sorted = res.results.sort((a, b) => (b.trustScore || 0) - (a.trustScore || 0));
+
+  table(
+    ["#", "Domain", "Trust", "Verified", "Capabilities"],
+    sorted.map((a, i) => [
+      i < 3 ? green(String(i + 1)) : dim(String(i + 1)),
+      cyan(a.domain),
+      bold(String(a.trustScore || 0)),
+      a.verified ? green("✓") : "",
+      (a.capabilities || []).slice(0, 3).join(", "),
+    ]),
+  );
+  nl();
+}

package/src/commands/login.js

@@ -0,0 +1,33 @@
+import * as readline from "node:readline/promises";
+import { save, load } from "../config.js";
+import { heading, success, info, nl, bold } from "../ui.js";
+
+export default async function login(args) {
+  const key = args[0];
+
+  if (key) {
+    const config = load();
+    config.api_key = key;
+    save(config);
+    success("API key saved");
+    return;
+  }
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  heading("Login", "Configure your aiia API key");
+  nl();
+
+  const apiKey = await rl.question(`  ${bold("API key:")} `);
+  const domain = await rl.question(`  ${bold("Domain")} (optional): `);
+  rl.close();
+
+  const config = load();
+  if (apiKey.trim()) config.api_key = apiKey.trim();
+  if (domain.trim()) config.domain = domain.trim();
+  save(config);
+
+  nl();
+  success("Config saved");
+  info("Run `aiia whoami` to verify");
+  nl();
+}

package/src/commands/monitor.js

@@ -0,0 +1,35 @@
+import { get } from "../api.js";
+import { getDomain } from "../config.js";
+import { heading, info, dim, bold, green, yellow, red, nl, trustBar, err } from "../ui.js";
+
+export default async function monitor(args) {
+  const domain = args[0] || getDomain();
+  if (!domain) err("Usage: aiia monitor <domain>");
+
+  const res = await get(`/api/monitoring/${domain}`);
+  if (res.error) err(res.error);
+
+  heading(`Monitor: ${domain}`);
+  nl();
+  console.log(`  ${bold("Uptime:")}          ${trustBar(res.uptimePercent || 0)} ${res.uptimePercent || 0}%`);
+  console.log(`  ${bold("Avg Response:")}     ${res.avgResponseTime ? `${res.avgResponseTime}ms` : "N/A"}`);
+  console.log(`  ${bold("SSL Valid:")}        ${res.sslValid ? green("yes") : red("no")}`);
+  console.log(`  ${bold("Total Checks:")}     ${res.totalChecks || 0}`);
+  console.log(`  ${bold("Successful:")}       ${res.successfulChecks || 0}`);
+  console.log(`  ${bold("Last Checked:")}     ${res.lastChecked ? dim(res.lastChecked) : "never"}`);
+
+  if (res.behavioral) {
+    nl();
+    console.log(`  ${bold("Content Fresh:")}    ${res.behavioral.contentFresh ? green("yes") : yellow("no")}`);
+  }
+
+  if (res.responseTimeHistory?.length) {
+    nl();
+    console.log(`  ${bold("Recent Crawls:")}`);
+    for (const h of res.responseTimeHistory.slice(0, 5)) {
+      const status = h.status === "success" ? green("✓") : red("✗");
+      console.log(`    ${status} ${dim(h.time)} ${h.ms ? `${h.ms}ms` : ""} ${dim(h.status)}`);
+    }
+  }
+  nl();
+}

package/src/commands/register.js

@@ -0,0 +1,50 @@
+import * as readline from "node:readline/promises";
+import { post } from "../api.js";
+import { save } from "../config.js";
+import { heading, success, fail, info, warn, nl, bold, cyan, dim, spinner } from "../ui.js";
+
+export default async function register(args) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  heading("Register your agent", "Join the aiia.ro agent registry");
+  nl();
+
+  const domain = await rl.question(`  ${bold("Domain:")} `);
+  const name = await rl.question(`  ${bold("Name:")} `);
+  const description = await rl.question(`  ${bold("Description:")} `);
+  const email = await rl.question(`  ${bold("Email:")} `);
+  const capabilities = await rl.question(`  ${bold("Capabilities")} ${dim("(comma-separated):")} `);
+  const protocols = await rl.question(`  ${bold("Protocols")} ${dim("(comma-separated):")} `);
+  const publicKey = await rl.question(`  ${bold("Public key")} ${dim("(base64, optional):")} `);
+  rl.close();
+
+  const s = spinner("Registering...");
+  const res = await post("/api/registry/register", {
+    domain: domain.trim(),
+    name: name.trim(),
+    description: description.trim(),
+    contact_email: email.trim(),
+    capabilities: capabilities.trim() ? capabilities.split(",").map((s) => s.trim()) : [],
+    protocols: protocols.trim() ? protocols.split(",").map((s) => s.trim()) : [],
+    public_key: publicKey.trim() || undefined,
+  });
+
+  if (res.error) { s.stop(`${fail(res.error)}`); return; }
+  s.stop(`${success("Agent registered")}`);
+
+  // Save config
+  save({ api_key: res.api_key, domain: res.agent.domain });
+  nl();
+  success(`API key: ${bold(res.api_key)}`);
+  warn("Store this key securely. It will not be shown again.");
+  info(`Config saved to ~/.aiia/config.json`);
+
+  if (res.verification) {
+    nl();
+    info("Verify your domain (pick one):");
+    for (const m of res.verification.methods) {
+      console.log(`    ${dim("•")} ${m.instruction}`);
+    }
+  }
+  nl();
+}

package/src/commands/review.js

@@ -0,0 +1,30 @@
+import * as readline from "node:readline/promises";
+import { post } from "../api.js";
+import { getDomain } from "../config.js";
+import { heading, success, fail, bold, dim, nl, err } from "../ui.js";
+
+export default async function review(args) {
+  const target = args[0];
+  if (!target) err("Usage: aiia review <domain>");
+  const myDomain = getDomain();
+  if (!myDomain) err("Not configured. Run `aiia login` first.");
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  heading(`Review ${target}`);
+  nl();
+  const rating = await rl.question(`  ${bold("Rating")} ${dim("(1-5):")} `);
+  const text = await rl.question(`  ${bold("Review:")} `);
+  rl.close();
+
+  const res = await post("/api/reviews/agent", {
+    reviewer_domain: myDomain,
+    reviewed_domain: target,
+    rating: parseInt(rating, 10),
+    text: text.trim(),
+  });
+
+  nl();
+  if (res.error) fail(res.error);
+  else success(`Review submitted for ${target}`);
+  nl();
+}

package/src/commands/search.js

@@ -0,0 +1,27 @@
+import { get } from "../api.js";
+import { heading, info, dim, cyan, bold, nl, table, spinner } from "../ui.js";
+
+export default async function search(args) {
+  const query = args.join(" ");
+  const s = spinner(query ? `Searching "${query}"...` : "Listing agents...");
+
+  const params = new URLSearchParams();
+  if (query) params.set("q", query);
+  params.set("limit", "20");
+
+  const res = await get(`/api/registry/search?${params}`);
+  s.stop(`  ${res.total || 0} agent${res.total !== 1 ? "s" : ""} found`);
+
+  if (!res.results?.length) { nl(); return; }
+
+  table(
+    ["Domain", "Trust", "Verified", "Capabilities"],
+    res.results.map((a) => [
+      cyan(a.domain),
+      String(a.trustScore || 0),
+      a.verified ? "✓" : "",
+      (a.capabilities || []).slice(0, 3).join(", "),
+    ]),
+  );
+  nl();
+}

package/src/commands/trust.js

@@ -0,0 +1,25 @@
+import { get } from "../api.js";
+import { getDomain } from "../config.js";
+import { heading, bold, dim, green, yellow, red, nl, trustBar, err } from "../ui.js";
+
+export default async function trust(args) {
+  const domain = args[0] || getDomain();
+  if (!domain) err("Usage: aiia trust <domain>");
+
+  const res = await get(`/api/trust/${domain}`);
+  if (res.error) err(res.error);
+
+  const b = res.breakdown || {};
+  const score = res.trustScore || 0;
+  const color = score >= 70 ? green : score >= 50 ? yellow : red;
+
+  heading(`Trust: ${domain}`);
+  console.log(`  ${bold("Score:")} ${color(String(score))}/100`);
+  nl();
+  console.log(`  AgentReady     ${trustBar(b.agentReadyScore || 0)}  ${b.agentReadyScore ?? "N/A"}/100`);
+  console.log(`  Endorsements   ${trustBar(Math.min(b.endorsementCount || 0, 10) * 10)}  ${b.endorsementCount || 0} received`);
+  console.log(`  Uptime         ${trustBar(b.uptimePercent || 0)}  ${b.uptimePercent || 0}%`);
+  console.log(`  Age            ${trustBar(Math.min(b.registrationAgeDays || 0, 90) / 90 * 100)}  ${b.registrationAgeDays || 0} days`);
+  console.log(`  Verified       ${trustBar(b.verified ? 100 : 0)}  ${b.verified ? "yes" : "no"}`);
+  nl();
+}

package/src/commands/validate.js

@@ -0,0 +1,52 @@
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { post } from "../api.js";
+import { heading, success, fail, warn, dim, green, red, yellow, nl, err } from "../ui.js";
+
+export default async function validate(args) {
+  let content;
+  const file = args[0];
+
+  if (file) {
+    if (!existsSync(file)) err(`File not found: ${file}`);
+    content = readFileSync(file, "utf8");
+  } else {
+    // Smart default: look for ai-agent.json in common locations
+    const candidates = [
+      ".well-known/ai-agent.json",
+      "ai-agent.json",
+      "public/.well-known/ai-agent.json",
+    ];
+    for (const c of candidates) {
+      if (existsSync(c)) {
+        content = readFileSync(c, "utf8");
+        heading(`Validating ${dim(c)}`);
+        break;
+      }
+    }
+    if (!content) err("No ai-agent.json found. Pass a file path or create .well-known/ai-agent.json");
+  }
+
+  const res = await post("/api/spec/validate", { json: content });
+
+  nl();
+  if (res.valid) {
+    success(green("Valid ai-agent.json"));
+  } else {
+    fail(red("Invalid ai-agent.json"));
+  }
+
+  if (res.errors?.length) {
+    nl();
+    for (const e of res.errors) {
+      console.log(`  ${red("✗")} ${e.path}: ${e.message}`);
+    }
+  }
+  if (res.warnings?.length) {
+    nl();
+    for (const w of res.warnings) {
+      console.log(`  ${yellow("⚠")} ${w.path}: ${w.message}`);
+    }
+  }
+  nl();
+}

package/src/commands/whoami.js

@@ -0,0 +1,32 @@
+import { getApiKey, getDomain, configPath } from "../config.js";
+import { get } from "../api.js";
+import { heading, success, fail, info, dim, bold, cyan, nl, badgeList } from "../ui.js";
+
+export default async function whoami() {
+  const key = getApiKey();
+  const domain = getDomain();
+
+  heading("whoami");
+  nl();
+
+  if (!key) {
+    fail("Not logged in. Run `aiia login` or `aiia register`.");
+    nl();
+    return;
+  }
+
+  info(`API key: ${dim(key.slice(0, 12) + "..." + key.slice(-4))}`);
+  info(`Config: ${dim(configPath())}`);
+
+  if (domain) {
+    info(`Domain: ${cyan(domain)}`);
+    const data = await get(`/api/registry/${domain}`);
+    if (data && !data.error) {
+      info(`Name: ${bold(data.name)}`);
+      info(`Verified: ${data.verified ? "✓ yes" : "✗ no"}`);
+      info(`Trust: ${data.trustScore || 0}/100`);
+      if (data.badges?.length) info(`Badges: ${data.badges.map((b) => `${b.icon} ${b.name}`).join("  ")}`);
+    }
+  }
+  nl();
+}

package/src/config.js

@@ -0,0 +1,31 @@
+import { homedir } from "node:os";
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+const CONFIG_DIR = join(homedir(), ".aiia");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+export function load() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+export function save(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+}
+
+export function getApiKey() {
+  return load().api_key || null;
+}
+
+export function getDomain() {
+  return load().domain || null;
+}
+
+export function configPath() {
+  return CONFIG_FILE;
+}

package/src/index.js

@@ -0,0 +1,82 @@
+import { bold, dim, cyan, nl, err } from "./ui.js";
+
+const COMMANDS = {
+  register:    () => import("./commands/register.js"),
+  login:       () => import("./commands/login.js"),
+  whoami:      () => import("./commands/whoami.js"),
+  search:      () => import("./commands/search.js"),
+  info:        () => import("./commands/info.js"),
+  leaderboard: () => import("./commands/leaderboard.js"),
+  check:       () => import("./commands/check.js"),
+  trust:       () => import("./commands/trust.js"),
+  endorse:     () => import("./commands/endorse.js"),
+  review:      () => import("./commands/review.js"),
+  badges:      () => import("./commands/badges.js"),
+  validate:    () => import("./commands/validate.js"),
+  monitor:     () => import("./commands/monitor.js"),
+  chat:        () => import("./commands/chat.js"),
+  key:         () => import("./commands/key.js"),
+};
+
+function showHelp() {
+  nl();
+  console.log(`  ${bold("aiia")} ${dim("— CLI for the agentic web")}`);
+  nl();
+  console.log(`  ${bold("Registry")}`);
+  console.log(`    ${cyan("register")}          Register your agent`);
+  console.log(`    ${cyan("search")} ${dim("[query]")}    Search agents`);
+  console.log(`    ${cyan("info")} ${dim("<domain>")}     Agent profile + trust + badges`);
+  console.log(`    ${cyan("leaderboard")}       Top agents by trust score`);
+  nl();
+  console.log(`  ${bold("Trust")}`);
+  console.log(`    ${cyan("trust")} ${dim("<domain>")}    Trust score breakdown`);
+  console.log(`    ${cyan("endorse")} ${dim("<domain>")}  Endorse an agent`);
+  console.log(`    ${cyan("review")} ${dim("<domain>")}   Review an agent (1-5 stars)`);
+  console.log(`    ${cyan("badges")} ${dim("<domain>")}   Show earned badges`);
+  console.log(`    ${cyan("monitor")} ${dim("<domain>")}  Uptime + response times`);
+  nl();
+  console.log(`  ${bold("Tools")}`);
+  console.log(`    ${cyan("check")} ${dim("<url>")}       Run AgentReady audit (15 checks)`);
+  console.log(`    ${cyan("validate")} ${dim("[file]")}   Validate ai-agent.json`);
+  nl();
+  console.log(`  ${bold("Chat")}`);
+  console.log(`    ${cyan("chat send")} ${dim("<domain> <msg>")}  Send encrypted message`);
+  console.log(`    ${cyan("chat inbox")}                  Read inbox`);
+  console.log(`    ${cyan("chat read")} ${dim("<id>")}            Read message`);
+  console.log(`    ${cyan("chat conversations")}          List conversations`);
+  nl();
+  console.log(`  ${bold("Auth")}`);
+  console.log(`    ${cyan("login")}             Set API key`);
+  console.log(`    ${cyan("whoami")}            Show current identity`);
+  console.log(`    ${cyan("key regenerate")}    Get new API key`);
+  nl();
+  console.log(`  ${dim("https://aiia.ro")}`);
+  nl();
+}
+
+export async function run(args) {
+  const cmd = args[0];
+  const rest = args.slice(1);
+
+  if (!cmd || cmd === "--help" || cmd === "-h" || cmd === "help") {
+    showHelp();
+    return;
+  }
+
+  if (cmd === "--version" || cmd === "-v") {
+    console.log("aiia 1.0.0");
+    return;
+  }
+
+  const loader = COMMANDS[cmd];
+  if (!loader) {
+    err(`Unknown command: ${cmd}\n  Run ${cyan("aiia --help")} for available commands.`);
+  }
+
+  try {
+    const mod = await loader();
+    await mod.default(rest);
+  } catch (e) {
+    err(e.message || "Command failed");
+  }
+}

package/src/ui.js

@@ -0,0 +1,82 @@
+import { styleText } from "node:util";
+
+const isTTY = process.stdout.isTTY;
+
+// Colors
+export const green = (s) => isTTY ? styleText("green", s) : s;
+export const red = (s) => isTTY ? styleText("red", s) : s;
+export const yellow = (s) => isTTY ? styleText("yellow", s) : s;
+export const cyan = (s) => isTTY ? styleText("cyan", s) : s;
+export const bold = (s) => isTTY ? styleText("bold", s) : s;
+export const dim = (s) => isTTY ? styleText("dim", s) : s;
+
+// Status messages
+export const success = (msg) => console.log(`  ${green("✓")} ${msg}`);
+export const fail = (msg) => console.log(`  ${red("✗")} ${msg}`);
+export const info = (msg) => console.log(`  ${cyan("ℹ")} ${msg}`);
+export const warn = (msg) => console.log(`  ${yellow("⚠")} ${msg}`);
+export const err = (msg) => { console.error(`\n  ${red("error:")} ${msg}\n`); process.exit(1); };
+
+// Heading
+export const heading = (title, subtitle) => {
+  console.log();
+  console.log(`  ${bold(title)}`);
+  if (subtitle) console.log(`  ${dim(subtitle)}`);
+};
+
+// Spinner
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+export function spinner(msg) {
+  if (!isTTY) { console.log(`  ${msg}`); return { stop: () => {}, update: () => {} }; }
+  let i = 0;
+  const id = setInterval(() => {
+    process.stdout.write(`\r  ${cyan(FRAMES[i++ % FRAMES.length])} ${msg}`);
+  }, 80);
+  return {
+    stop: (finalMsg) => {
+      clearInterval(id);
+      process.stdout.write(`\r  ${finalMsg || msg}${" ".repeat(20)}\n`);
+    },
+    update: (newMsg) => { msg = newMsg; },
+  };
+}
+
+// Trust bar
+export function trustBar(value, max = 100, width = 10) {
+  const filled = Math.round((value / max) * width);
+  const bar = "█".repeat(Math.max(0, filled)) + "░".repeat(Math.max(0, width - filled));
+  const color = value / max >= 0.7 ? green : value / max >= 0.5 ? yellow : red;
+  return color(bar);
+}
+
+// Stars
+export function stars(rating, max = 5) {
+  const full = Math.round(rating);
+  return yellow("★".repeat(full)) + dim("☆".repeat(max - full));
+}
+
+// Table
+export function table(headers, rows) {
+  const widths = headers.map((h, i) =>
+    Math.max(h.length, ...rows.map((r) => String(r[i] || "").length))
+  );
+  const sep = "  ";
+
+  console.log();
+  console.log(
+    sep + headers.map((h, i) => dim(h.toUpperCase().padEnd(widths[i]))).join("  ")
+  );
+  for (const row of rows) {
+    console.log(
+      sep + row.map((cell, i) => String(cell || "").padEnd(widths[i])).join("  ")
+    );
+  }
+}
+
+// Badge display
+export function badgeList(badges) {
+  return badges.filter((b) => b.earned).map((b) => `${b.icon} ${b.name}`).join("  ");
+}
+
+// Blank line
+export const nl = () => console.log();