@tasknet-protocol/cli 0.4.0 → 0.6.0

package/dist/index.js

@@ -9,6 +9,68 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/config.ts
+var config_exports = {};
+__export(config_exports, {
+  clearConfig: () => clearConfig,
+  config: () => config,
+  getConfig: () => getConfig,
+  getConfigPath: () => getConfigPath,
+  setConfig: () => setConfig
+});
+import Conf from "conf";
+function getConfig() {
+  return {
+    apiUrl: config.get("apiUrl"),
+    apiKey: config.get("apiKey"),
+    network: config.get("network"),
+    rpcUrl: config.get("rpcUrl"),
+    packageId: config.get("packageId"),
+    walrusAggregator: config.get("walrusAggregator"),
+    walrusPublisher: config.get("walrusPublisher"),
+    agentId: config.get("agentId"),
+    agentName: config.get("agentName"),
+    outputFormat: config.get("outputFormat")
+  };
+}
+function setConfig(key, value) {
+  config.set(key, value);
+}
+function clearConfig() {
+  config.clear();
+}
+function getConfigPath() {
+  return config.path;
+}
+var defaults, config;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    defaults = {
+      apiUrl: "http://localhost:3000",
+      network: "testnet",
+      outputFormat: "table"
+    };
+    config = new Conf({
+      projectName: "tasknet-cli",
+      projectVersion: "0.6.0",
+      defaults,
+      schema: {
+        apiUrl: { type: "string" },
+        apiKey: { type: "string" },
+        network: { type: "string", enum: ["mainnet", "testnet", "devnet", "localnet"] },
+        rpcUrl: { type: "string" },
+        packageId: { type: "string" },
+        walrusAggregator: { type: "string" },
+        walrusPublisher: { type: "string" },
+        agentId: { type: "string" },
+        agentName: { type: "string" },
+        outputFormat: { type: "string", enum: ["table", "json"] }
+      }
+    });
+  }
+});
+
 // ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/cryptoNode.js
 import * as nc from "crypto";
 var crypto;
@@ -12406,57 +12468,13 @@ var init_cryptography = __esm({
 
 // src/index.ts
 import { Command as Command2 } from "commander";
-import chalk4 from "chalk";
+import chalk3 from "chalk";
 
-// src/config.ts
-import Conf from "conf";
-var defaults = {
-  apiUrl: "http://localhost:3000",
-  network: "testnet",
-  outputFormat: "table"
-};
-var config = new Conf({
-  projectName: "tasknet-cli",
-  projectVersion: "0.4.0",
-  defaults,
-  schema: {
-    apiUrl: { type: "string" },
-    apiKey: { type: "string" },
-    network: { type: "string", enum: ["mainnet", "testnet", "devnet", "localnet"] },
-    rpcUrl: { type: "string" },
-    packageId: { type: "string" },
-    walrusAggregator: { type: "string" },
-    walrusPublisher: { type: "string" },
-    agentId: { type: "string" },
-    agentName: { type: "string" },
-    outputFormat: { type: "string", enum: ["table", "json"] }
-  }
-});
-function getConfig() {
-  return {
-    apiUrl: config.get("apiUrl"),
-    apiKey: config.get("apiKey"),
-    network: config.get("network"),
-    rpcUrl: config.get("rpcUrl"),
-    packageId: config.get("packageId"),
-    walrusAggregator: config.get("walrusAggregator"),
-    walrusPublisher: config.get("walrusPublisher"),
-    agentId: config.get("agentId"),
-    agentName: config.get("agentName"),
-    outputFormat: config.get("outputFormat")
-  };
-}
-function setConfig(key, value) {
-  config.set(key, value);
-}
-function clearConfig() {
-  config.clear();
-}
-function getConfigPath() {
-  return config.path;
-}
+// src/commands/config.ts
+init_config();
 
 // src/utils.ts
+init_config();
 import chalk from "chalk";
 import ora from "ora";
 var colors = {
@@ -12536,6 +12554,19 @@ function output(data, tableFormatter) {
     jsonOutput(data);
   }
 }
+function requireConfig(key) {
+  const config2 = getConfig();
+  const value = config2[key];
+  if (!value) {
+    error(`Missing configuration: ${key}`);
+    error(`Run: tasknet config set ${key} <value>`);
+    process.exit(1);
+  }
+  return value;
+}
+function requireApiKey() {
+  return requireConfig("apiKey");
+}
 
 // src/commands/config.ts
 function registerConfigCommands(program2) {
@@ -12630,6 +12661,7 @@ Valid keys: ${validKeys.join(", ")}`);
 }
 
 // src/client.ts
+init_config();
 import { TaskNetClient } from "@tasknet-protocol/sdk";
 var clientInstance = null;
 function getClient() {
@@ -12649,6 +12681,7 @@ function getClient() {
 }
 
 // src/commands/agent.ts
+init_config();
 function generateSignatureChallenge(agentId, action, timestamp) {
   return `TaskNet Verification
 
@@ -13300,6 +13333,7 @@ ${colors.primary("Search Results")} for "${query}"
 
 // src/commands/task.ts
 import { STATUS } from "@tasknet-protocol/shared";
+init_config();
 function registerTaskCommands(program2) {
   const taskCmd = program2.command("task").alias("tasks").description("Manage tasks");
   taskCmd.command("list").description("List tasks").option("-p, --page <number>", "Page number", "1").option("-l, --limit <number>", "Items per page", "20").option("-s, --status <status>", "Filter by status (0-9)").option("--skill <id>", "Filter by skill ID").option("--requester <id>", "Filter by requester agent ID").option("--worker <id>", "Filter by worker agent ID").option("--mine", "Show my tasks (as requester or worker)").option("--available", "Show only available tasks (Posted status)").option("--sort <field>", "Sort by: created_at, expires_at, payment, priority", "created_at").option("-o, --order <dir>", "Sort order: asc, desc", "desc").action(async (options) => {
@@ -13457,7 +13491,7 @@ ${colors.primary("Recent Events")}
 ${colors.primary("Watching for tasks...")} (Ctrl+C to stop)
 `);
     const interval = parseInt(options.interval) * 1e3;
-    let seenTasks = /* @__PURE__ */ new Set();
+    const seenTasks = /* @__PURE__ */ new Set();
     const poll = async () => {
       try {
         const client = getClient();
@@ -13552,220 +13586,14 @@ ${colors.primary("Statistics")}
   });
 }
 
-// src/commands/claim.ts
+// src/commands/badge.ts
 import chalk2 from "chalk";
 import ora2 from "ora";
-import { CLAIM_LABELS } from "@tasknet-protocol/shared";
-function registerClaimCommands(program2) {
-  const claim = program2.command("claim").description("Manage identity claims and verification");
-  claim.command("generate").description("Generate a verification code for identity claims").option(
-    "-t, --type <type>",
-    "Claim type: x, github, moltbook, wallet",
-    "wallet"
-  ).action(async (options) => {
-    const spin = ora2("Generating claim...").start();
-    try {
-      const client = getClient();
-      const typeMap = {
-        x: 1,
-        twitter: 1,
-        moltbook: 2,
-        github: 3,
-        wallet: 4
-      };
-      const claimType = typeMap[options.type.toLowerCase()] ?? 0;
-      const result = await client.api.generateClaim(claimType);
-      spin.succeed("Claim generated successfully");
-      output(result, () => {
-        let out = `
-${colors.primary("Claim Details")}
-
-`;
-        out += `${colors.muted("ID:")}                  ${result.claim.id}
-`;
-        out += `${colors.muted("Type:")}                ${getClaimTypeLabel(result.claim.claim_type)}
-`;
-        out += `${colors.muted("Status:")}              ${chalk2.yellow(result.claim.status)}
-`;
-        out += `${colors.muted("Created:")}             ${result.claim.created_at}
-`;
-        out += `
-${colors.primary("Verification Code")}
-`;
-        out += `${chalk2.cyan(result.claim.verification_code)}
-`;
-        out += `
-${colors.primary("Instructions")}
-`;
-        out += `${result.instructions}
-`;
-        return out;
-      });
-    } catch (error2) {
-      spin.fail(chalk2.red("Failed to generate claim"));
-      const err = error2;
-      console.error(chalk2.red(err.message));
-      process.exit(1);
-    }
-  });
-  claim.command("verify <claimId>").description("Verify a claim with proof").option("-u, --url <url>", "Proof URL (for X, GitHub, Moltbook)").option("-s, --signature <sig>", "Wallet signature (for wallet claims)").action(async (claimId, options) => {
-    const spin = ora2("Verifying claim...").start();
-    try {
-      const client = getClient();
-      const result = await client.api.verifyClaim({
-        claimId,
-        proofUrl: options.url,
-        signature: options.signature
-      });
-      spin.succeed("Claim verified successfully");
-      output(result, () => {
-        let out = `
-${colors.primary("Verified Claim")}
-
-`;
-        out += `${colors.muted("ID:")}            ${result.claim.id}
-`;
-        out += `${colors.muted("Type:")}          ${result.claim.claim_type_label}
-`;
-        out += `${colors.muted("Status:")}        ${chalk2.green(result.claim.status)}
-`;
-        out += `${colors.muted("Claimed By:")}    ${result.claim.claimed_by ?? "N/A"}
-`;
-        out += `${colors.muted("Verified At:")}   ${result.claim.verified_at ?? "N/A"}
-`;
-        return out;
-      });
-    } catch (error2) {
-      spin.fail(chalk2.red("Failed to verify claim"));
-      const err = error2;
-      console.error(chalk2.red(err.message));
-      process.exit(1);
-    }
-  });
-  claim.command("get <claimId>").description("Get details of a specific claim").action(async (claimId) => {
-    const spin = ora2("Fetching claim...").start();
-    try {
-      const client = getClient();
-      const claimData = await client.api.getClaim(claimId);
-      spin.succeed("Claim fetched");
-      output(claimData, () => {
-        let out = `
-${colors.primary("Claim Details")}
-
-`;
-        out += `${colors.muted("ID:")}                  ${claimData.id}
-`;
-        out += `${colors.muted("Agent ID:")}            ${formatAddress(claimData.agent_id)}
-`;
-        out += `${colors.muted("Type:")}                ${claimData.claim_type_label}
-`;
-        out += `${colors.muted("Status:")}              ${getStatusColor2(claimData.status)}
-`;
-        out += `${colors.muted("Verification Code:")}   ${claimData.verification_code.slice(0, 30)}...
-`;
-        out += `${colors.muted("Claimed By:")}          ${claimData.claimed_by ?? "N/A"}
-`;
-        out += `${colors.muted("Created At:")}          ${claimData.created_at}
-`;
-        out += `${colors.muted("Verified At:")}         ${claimData.verified_at ?? "N/A"}
-`;
-        out += `
-${colors.primary("Agent")}
-`;
-        out += `${colors.muted("ID:")}                  ${claimData.agent.id}
-`;
-        out += `${colors.muted("Owner:")}               ${formatAddress(claimData.agent.owner)}
-`;
-        return out;
-      });
-    } catch (error2) {
-      spin.fail(chalk2.red("Failed to fetch claim"));
-      const err = error2;
-      console.error(chalk2.red(err.message));
-      process.exit(1);
-    }
-  });
-  claim.command("revoke <claimId>").description("Revoke a verified claim").action(async (claimId) => {
-    const spin = ora2("Revoking claim...").start();
-    try {
-      const client = getClient();
-      await client.api.revokeClaim(claimId);
-      spin.succeed("Claim revoked successfully");
-    } catch (error2) {
-      spin.fail(chalk2.red("Failed to revoke claim"));
-      const err = error2;
-      console.error(chalk2.red(err.message));
-      process.exit(1);
-    }
-  });
-  claim.command("list").description("List claims for the current agent").action(async () => {
-    const spin = ora2("Fetching claims...").start();
-    try {
-      const client = getClient();
-      const agentId = client.getAgentId();
-      if (!agentId) {
-        spin.fail("No active agent set. Use 'tasknet config set agentId <id>'");
-        process.exit(1);
-      }
-      const agent = await client.api.getAgent(agentId);
-      spin.succeed(`Found ${agent.claims.length} claims`);
-      output(agent.claims, () => {
-        if (agent.claims.length === 0) {
-          return `
-${chalk2.yellow("No claims found.")}
-Generate a claim with: tasknet claim generate -t wallet
-`;
-        }
-        let out = `
-${colors.primary("Claims")}
-
-`;
-        out += `${colors.muted("ID".padEnd(20))}  ${colors.muted("Type".padEnd(15))}  ${colors.muted("Claimed By".padEnd(22))}  ${colors.muted("Verified At")}
-`;
-        out += `${colors.muted("-".repeat(20))}  ${colors.muted("-".repeat(15))}  ${colors.muted("-".repeat(22))}  ${colors.muted("-".repeat(20))}
-`;
-        for (const c of agent.claims) {
-          const id = c.id.slice(0, 18) + "..";
-          const type = getClaimTypeLabel(c.claim_type).padEnd(15);
-          const claimedBy = (c.claimed_by?.slice(0, 20) ?? "N/A").padEnd(22);
-          const verifiedAt = c.verified_at ?? chalk2.yellow("Pending");
-          out += `${id}  ${type}  ${claimedBy}  ${verifiedAt}
-`;
-        }
-        return out;
-      });
-    } catch (error2) {
-      spin.fail(chalk2.red("Failed to fetch claims"));
-      const err = error2;
-      console.error(chalk2.red(err.message));
-      process.exit(1);
-    }
-  });
-}
-function getClaimTypeLabel(type) {
-  return CLAIM_LABELS[type] ?? `Type ${type}`;
-}
-function getStatusColor2(status) {
-  switch (status) {
-    case "verified":
-      return chalk2.green(status);
-    case "pending":
-      return chalk2.yellow(status);
-    case "revoked":
-      return chalk2.red(status);
-    default:
-      return status;
-  }
-}
-
-// src/commands/badge.ts
-import chalk3 from "chalk";
-import ora3 from "ora";
 import { BADGE_TIER } from "@tasknet-protocol/shared";
 function registerBadgeCommands(program2) {
   const badge = program2.command("badge").description("View agent reputation badges");
   badge.command("list [agentId]").description("List badges for an agent (defaults to current agent)").action(async (agentId) => {
-    const spin = ora3("Fetching badges...").start();
+    const spin = ora2("Fetching badges...").start();
     try {
       const client = getClient();
       const targetId = agentId ?? client.getAgentId();
@@ -13778,7 +13606,7 @@ function registerBadgeCommands(program2) {
       output(agent.badges, () => {
         if (agent.badges.length === 0) {
           return `
-${chalk3.yellow("No badges earned yet.")}
+${chalk2.yellow("No badges earned yet.")}
 Complete tasks and verify your identity to earn badges!
 `;
         }
@@ -13807,17 +13635,17 @@ ${colors.primary(`Badges for ${targetId.slice(0, 16)}...`)}
         out += `
 ${colors.primary("Summary")}
 `;
-        out += `  ${chalk3.hex("#CD7F32")("\u25CF")} Bronze: ${tierCounts.bronze}  `;
-        out += `${chalk3.gray("\u25CF")} Silver: ${tierCounts.silver}  `;
-        out += `${chalk3.yellow("\u25CF")} Gold: ${tierCounts.gold}  `;
-        out += `${chalk3.magenta("\u25CF")} Platinum: ${tierCounts.platinum}
+        out += `  ${chalk2.hex("#CD7F32")("\u25CF")} Bronze: ${tierCounts.bronze}  `;
+        out += `${chalk2.gray("\u25CF")} Silver: ${tierCounts.silver}  `;
+        out += `${chalk2.yellow("\u25CF")} Gold: ${tierCounts.gold}  `;
+        out += `${chalk2.magenta("\u25CF")} Platinum: ${tierCounts.platinum}
 `;
         return out;
       });
     } catch (error2) {
-      spin.fail(chalk3.red("Failed to fetch badges"));
+      spin.fail(chalk2.red("Failed to fetch badges"));
       const err = error2;
-      console.error(chalk3.red(err.message));
+      console.error(chalk2.red(err.message));
       process.exit(1);
     }
   });
@@ -13877,28 +13705,28 @@ ${colors.primary("Available Badges")}
       }
     ];
     for (const b of badges) {
-      out += `  ${b.icon} ${chalk3.bold(formatBadgeType(b.type))}
+      out += `  ${b.icon} ${chalk2.bold(formatBadgeType(b.type))}
 `;
-      out += `     ${chalk3.gray(b.description)}
+      out += `     ${chalk2.gray(b.description)}
 `;
-      out += `     ${chalk3.cyan("How to earn:")} ${b.howToEarn}
+      out += `     ${chalk2.cyan("How to earn:")} ${b.howToEarn}
 
 `;
     }
     out += `${colors.primary("Tiers")}
 `;
-    out += `  ${chalk3.hex("#CD7F32")("\u25CF")} Bronze   - Entry level
+    out += `  ${chalk2.hex("#CD7F32")("\u25CF")} Bronze   - Entry level
 `;
-    out += `  ${chalk3.gray("\u25CF")} Silver   - Intermediate
+    out += `  ${chalk2.gray("\u25CF")} Silver   - Intermediate
 `;
-    out += `  ${chalk3.yellow("\u25CF")} Gold     - Advanced
+    out += `  ${chalk2.yellow("\u25CF")} Gold     - Advanced
 `;
-    out += `  ${chalk3.magenta("\u25CF")} Platinum - Expert
+    out += `  ${chalk2.magenta("\u25CF")} Platinum - Expert
 `;
     console.log(out);
   });
   badge.command("showcase [agentId]").description("Display badges in a showcase format").action(async (agentId) => {
-    const spin = ora3("Loading showcase...").start();
+    const spin = ora2("Loading showcase...").start();
     try {
       const client = getClient();
       const targetId = agentId ?? client.getAgentId();
@@ -13909,7 +13737,7 @@ ${colors.primary("Available Badges")}
       const agent = await client.api.getAgent(targetId);
       spin.stop();
       if (agent.badges.length === 0) {
-        console.log(chalk3.yellow("\nNo badges to showcase yet."));
+        console.log(chalk2.yellow("\nNo badges to showcase yet."));
         return;
       }
       const byTier = {};
@@ -13918,7 +13746,7 @@ ${colors.primary("Available Badges")}
         byTier[b.tier].push(b);
       }
       let out = `
-${chalk3.bold.underline("\u{1F3C6} Badge Showcase")}
+${chalk2.bold.underline("\u{1F3C6} Badge Showcase")}
 
 `;
       for (const tier of [3, 2, 1, 0]) {
@@ -13926,7 +13754,7 @@ ${chalk3.bold.underline("\u{1F3C6} Badge Showcase")}
         if (!tierBadges || tierBadges.length === 0) continue;
         const tierName = getTierName(tier);
         const tierColor = getTierColor(tier);
-        out += tierColor(chalk3.bold(`\u2501\u2501\u2501 ${tierName.toUpperCase()} \u2501\u2501\u2501`)) + "\n\n";
+        out += tierColor(chalk2.bold(`\u2501\u2501\u2501 ${tierName.toUpperCase()} \u2501\u2501\u2501`)) + "\n\n";
         for (const b of tierBadges) {
           out += `  ${getBadgeIcon(b.badge_type)} ${formatBadgeType(b.badge_type)}
 `;
@@ -13946,9 +13774,9 @@ ${chalk3.bold.underline("\u{1F3C6} Badge Showcase")}
       }
       console.log(out);
     } catch (error2) {
-      spin.fail(chalk3.red("Failed to load showcase"));
+      spin.fail(chalk2.red("Failed to load showcase"));
       const err = error2;
-      console.error(chalk3.red(err.message));
+      console.error(chalk2.red(err.message));
       process.exit(1);
     }
   });
@@ -13983,21 +13811,245 @@ function getTierDisplay(tier) {
 function getTierColor(tier) {
   switch (tier) {
     case BADGE_TIER.BRONZE:
-      return chalk3.hex("#CD7F32");
+      return chalk2.hex("#CD7F32");
     case BADGE_TIER.SILVER:
-      return chalk3.gray;
+      return chalk2.gray;
     case BADGE_TIER.GOLD:
-      return chalk3.yellow;
+      return chalk2.yellow;
     case 3:
-      return chalk3.magenta;
+      return chalk2.magenta;
     default:
-      return chalk3.white;
+      return chalk2.white;
   }
 }
 
+// src/commands/claim.ts
+import { CLAIM_TYPE, CLAIM_TYPE_LABELS, CLAIM_STATUS_LABELS } from "@tasknet-protocol/shared";
+function registerClaimCommands(program2) {
+  const claimCmd = program2.command("claim").description("Identity verification commands");
+  claimCmd.command("generate <type>").description("Generate a verification claim").addHelpText(
+    "after",
+    `
+Claim Types:
+  twitter   - Verify via Twitter/X post
+  moltbook  - Verify via Moltbook post
+  github    - Verify via GitHub Gist
+  wallet    - Verify via wallet signature
+
+Examples:
+  $ tasknet claim generate twitter
+  $ tasknet claim generate github
+  $ tasknet claim generate wallet
+`
+  ).action(async (type) => {
+    await requireApiKey();
+    const client = getClient();
+    const typeMap = {
+      twitter: CLAIM_TYPE.TWITTER,
+      x: CLAIM_TYPE.TWITTER,
+      moltbook: CLAIM_TYPE.MOLTBOOK,
+      github: CLAIM_TYPE.GITHUB,
+      wallet: CLAIM_TYPE.WALLET
+    };
+    const claimType = typeMap[type.toLowerCase()];
+    if (claimType === void 0) {
+      error(`Invalid claim type: ${type}`);
+      log("Valid types: twitter, moltbook, github, wallet");
+      process.exit(1);
+    }
+    const spin = spinner(`Generating ${type} claim...`).start();
+    try {
+      const result = await client.api.generateClaim(claimType);
+      spin.stop();
+      success(`Claim generated successfully!
+`);
+      output(result, () => {
+        let str = `${colors.primary("Claim Details")}
+
+`;
+        str += `  Claim ID:   ${result.claim_id}
+`;
+        str += `  Type:       ${result.claim_type}
+`;
+        str += `  Status:     ${result.status}
+`;
+        str += `  Code:       ${colors.success(result.verification_code)}
+
+`;
+        str += `${colors.primary("Instructions")}
+
+`;
+        str += `  ${result.instructions.split("\n").join("\n  ")}
+
+`;
+        str += `${colors.muted("Next step:")}
+`;
+        str += `  After completing the verification step, run:
+`;
+        str += `  tasknet claim verify ${result.claim_id} <post_url_or_signature>
+`;
+        return str;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Failed to generate claim: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  claimCmd.command("verify <claim-id> <proof>").description("Verify a pending claim with post URL or signature").addHelpText(
+    "after",
+    `
+Arguments:
+  claim-id  - The claim ID from 'claim generate'
+  proof     - Post URL (twitter/moltbook/github) or wallet signature
+
+Examples:
+  $ tasknet claim verify abc123 https://twitter.com/user/status/123456789
+  $ tasknet claim verify abc123 https://gist.github.com/user/abc123
+  $ tasknet claim verify abc123 <base64-signature>
+`
+  ).action(async (claimId, proof) => {
+    await requireApiKey();
+    const client = getClient();
+    const spin = spinner("Verifying claim...").start();
+    try {
+      const isUrl = proof.startsWith("http");
+      const result = await client.api.verifyClaim({
+        claimId,
+        postUrl: isUrl ? proof : void 0,
+        signature: !isUrl ? proof : void 0
+      });
+      spin.stop();
+      success(`Claim verified successfully!
+`);
+      output(result, () => {
+        let str = `${colors.primary("Verification Result")}
+
+`;
+        str += `  Claim ID:   ${result.claim_id}
+`;
+        str += `  Type:       ${result.claim_type}
+`;
+        str += `  Handle:     ${result.verified_handle || "N/A"}
+`;
+        str += `  Verified:   ${result.verified_at}
+`;
+        if (result.badge_awarded) {
+          str += `
+  \u{1F3C5} Badge Awarded: ${result.badge_awarded}
+`;
+        }
+        return str;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Verification failed: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  claimCmd.command("status <claim-id>").description("Get claim status").action(async (claimId) => {
+    const client = getClient();
+    const spin = spinner("Fetching claim...").start();
+    try {
+      const result = await client.api.getClaim(claimId);
+      spin.stop();
+      output(result, () => {
+        let str = `${colors.primary("Claim Details")}
+
+`;
+        str += `  ID:         ${result.id}
+`;
+        str += `  Agent:      ${result.agent_id}
+`;
+        str += `  Type:       ${result.claim_type_label}
+`;
+        str += `  Status:     ${result.status_label}
+`;
+        if (result.verification_code) {
+          str += `  Code:       ${result.verification_code}
+`;
+        }
+        if (result.verified_handle) {
+          str += `  Handle:     ${result.verified_handle}
+`;
+        }
+        if (result.post_url) {
+          str += `  Post URL:   ${result.post_url}
+`;
+        }
+        str += `  Created:    ${result.created_at}
+`;
+        if (result.verified_at) {
+          str += `  Verified:   ${result.verified_at}
+`;
+        }
+        if (result.revoked_at) {
+          str += `  Revoked:    ${result.revoked_at}
+`;
+        }
+        return str;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Failed to fetch claim: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  claimCmd.command("revoke <claim-id>").description("Revoke a verification claim").action(async (claimId) => {
+    await requireApiKey();
+    const client = getClient();
+    const spin = spinner("Revoking claim...").start();
+    try {
+      const result = await client.api.revokeClaim(claimId);
+      spin.stop();
+      success(result.message);
+    } catch (err) {
+      spin.stop();
+      error(`Failed to revoke claim: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  claimCmd.command("list").description("List your claims (requires linked agent)").action(async () => {
+    await requireApiKey();
+    const client = getClient();
+    const spin = spinner("Fetching claims...").start();
+    try {
+      const config2 = await Promise.resolve().then(() => (init_config(), config_exports)).then((m) => m.getConfig());
+      if (!config2.agentId) {
+        spin.stop();
+        error("No agent linked. Use 'tasknet agent link' first.");
+        process.exit(1);
+      }
+      const agent = await client.api.getAgent(config2.agentId);
+      spin.stop();
+      if (!agent.claims || agent.claims.length === 0) {
+        log("No claims found for this agent.\n");
+        log("Generate a claim with: tasknet claim generate <type>");
+        return;
+      }
+      log(`
+${colors.primary("Your Claims")}
+`);
+      const table2 = agent.claims.map((c) => ({
+        ID: c.id.slice(0, 8) + "...",
+        Type: c.claim_type_label || CLAIM_TYPE_LABELS[c.claim_type] || "Unknown",
+        Status: c.status_label || CLAIM_STATUS_LABELS[c.status] || "Unknown",
+        Handle: c.verified_handle || "-",
+        "Verified At": c.verified_at || "-"
+      }));
+      console.table(table2);
+    } catch (err) {
+      spin.stop();
+      error(`Failed to list claims: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
 // src/index.ts
+init_config();
 var program = new Command2();
-var banner = chalk4.cyan(`
+var banner = chalk3.cyan(`
   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
   \u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551 \u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D
      \u2588\u2588\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557     \u2588\u2588\u2551   
@@ -14005,7 +14057,7 @@ var banner = chalk4.cyan(`
      \u2588\u2588\u2551   \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2557\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2551   
      \u255A\u2550\u255D   \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D   \u255A\u2550\u255D   
 `);
-program.name("tasknet").description("CLI for TaskNet Protocol - Agent-to-Agent Skills Marketplace").version("0.4.0").addHelpText("beforeAll", banner).option("--json", "Output as JSON").hook("preAction", (thisCommand) => {
+program.name("tasknet").description("CLI for TaskNet Protocol - Agent-to-Agent Skills Marketplace").version("0.6.0").addHelpText("beforeAll", banner).option("--json", "Output as JSON").hook("preAction", (thisCommand) => {
   const opts = thisCommand.opts();
   if (opts.json) {
     const config2 = getConfig();
@@ -14016,8 +14068,8 @@ registerConfigCommands(program);
 registerAgentCommands(program);
 registerSkillCommands(program);
 registerTaskCommands(program);
-registerClaimCommands(program);
 registerBadgeCommands(program);
+registerClaimCommands(program);
 registerHealthCommand(program);
 program.parse();
 /*! Bundled license information: