@tasknet-protocol/cli 0.2.0

package/dist/index.js

@@ -0,0 +1,1299 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import chalk4 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.2.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/utils.ts
+import chalk from "chalk";
+import ora from "ora";
+var colors = {
+  primary: chalk.cyan,
+  success: chalk.green,
+  warning: chalk.yellow,
+  error: chalk.red,
+  muted: chalk.gray,
+  highlight: chalk.bold.white
+};
+function log(message) {
+  console.log(message);
+}
+function success(message) {
+  console.log(colors.success("\u2713"), message);
+}
+function error(message) {
+  console.error(colors.error("\u2717"), message);
+}
+function spinner(text) {
+  return ora({ text, color: "cyan" });
+}
+function formatAddress(address, length = 8) {
+  if (address.length <= length * 2 + 2) return address;
+  return `${address.slice(0, length + 2)}...${address.slice(-length)}`;
+}
+function formatUsdc(amount) {
+  const value = typeof amount === "string" ? BigInt(amount) : amount;
+  const usdc = Number(value) / 1e6;
+  return `${usdc.toFixed(2)} USDC`;
+}
+function formatTimestamp(timestamp) {
+  const ms = typeof timestamp === "bigint" ? Number(timestamp) : Number(timestamp);
+  return new Date(ms).toLocaleString();
+}
+function formatDuration(seconds) {
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h`;
+  return `${Math.floor(seconds / 86400)}d`;
+}
+function formatPercent(value) {
+  if (value === null || value === void 0) return "-";
+  return `${(value * 100).toFixed(1)}%`;
+}
+function table(headers, rows, options = {}) {
+  const maxWidth = options.maxWidth ?? 20;
+  const widths = headers.map(
+    (h, i) => Math.min(
+      maxWidth,
+      Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length))
+    )
+  );
+  const headerLine = headers.map((h, i) => h.padEnd(widths[i])).join("  ");
+  const separator = widths.map((w) => "-".repeat(w)).join("  ");
+  const rowLines = rows.map(
+    (row) => row.map((cell, i) => (cell ?? "").padEnd(widths[i])).join("  ")
+  );
+  return [
+    colors.muted(headerLine),
+    colors.muted(separator),
+    ...rowLines
+  ].join("\n");
+}
+function jsonOutput(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function output(data, tableFormatter) {
+  const config2 = getConfig();
+  if (config2.outputFormat === "json") {
+    jsonOutput(data);
+  } else if (tableFormatter) {
+    log(tableFormatter());
+  } else {
+    jsonOutput(data);
+  }
+}
+
+// src/commands/config.ts
+function registerConfigCommands(program2) {
+  const configCmd = program2.command("config").description("Manage CLI configuration");
+  configCmd.command("show").description("Show current configuration").option("--json", "Output as JSON").action((options) => {
+    const config2 = getConfig();
+    if (options.json) {
+      console.log(JSON.stringify(config2, null, 2));
+      return;
+    }
+    log(colors.primary("\nTaskNet CLI Configuration\n"));
+    log(colors.muted(`Config file: ${getConfigPath()}
+`));
+    const rows = Object.entries(config2).map(([key, value]) => [
+      colors.highlight(key),
+      value !== void 0 ? String(value) : colors.muted("(not set)")
+    ]);
+    log(table(["Key", "Value"], rows));
+    log("");
+  });
+  configCmd.command("get <key>").description("Get a configuration value").action((key) => {
+    const config2 = getConfig();
+    const value = config2[key];
+    if (value === void 0) {
+      error(`Configuration key "${key}" is not set`);
+      process.exit(1);
+    }
+    log(String(value));
+  });
+  configCmd.command("set <key> <value>").description("Set a configuration value").action((key, value) => {
+    const validKeys = [
+      "apiUrl",
+      "apiKey",
+      "network",
+      "rpcUrl",
+      "packageId",
+      "walrusAggregator",
+      "walrusPublisher",
+      "agentId",
+      "agentName",
+      "outputFormat"
+    ];
+    if (!validKeys.includes(key)) {
+      error(`Invalid configuration key: ${key}`);
+      log(`
+Valid keys: ${validKeys.join(", ")}`);
+      process.exit(1);
+    }
+    if (key === "network") {
+      const validNetworks = ["mainnet", "testnet", "devnet", "localnet"];
+      if (!validNetworks.includes(value)) {
+        error(`Invalid network: ${value}`);
+        log(`Valid networks: ${validNetworks.join(", ")}`);
+        process.exit(1);
+      }
+    }
+    if (key === "outputFormat") {
+      const validFormats = ["table", "json"];
+      if (!validFormats.includes(value)) {
+        error(`Invalid output format: ${value}`);
+        log(`Valid formats: ${validFormats.join(", ")}`);
+        process.exit(1);
+      }
+    }
+    setConfig(key, value);
+    success(`Set ${key} = ${value}`);
+  });
+  configCmd.command("unset <key>").description("Unset a configuration value").action((key) => {
+    setConfig(key, void 0);
+    success(`Unset ${key}`);
+  });
+  configCmd.command("reset").description("Reset all configuration to defaults").option("-y, --yes", "Skip confirmation").action(async (options) => {
+    if (!options.yes) {
+      const prompts = await import("prompts");
+      const { confirm } = await prompts.default({
+        type: "confirm",
+        name: "confirm",
+        message: "Reset all configuration to defaults?",
+        initial: false
+      });
+      if (!confirm) {
+        log("Cancelled");
+        return;
+      }
+    }
+    clearConfig();
+    success("Configuration reset to defaults");
+  });
+  configCmd.command("path").description("Show configuration file path").action(() => {
+    log(getConfigPath());
+  });
+}
+
+// src/client.ts
+import { TaskNetClient } from "@tasknet-protocol/sdk";
+var clientInstance = null;
+function getClient() {
+  if (clientInstance) return clientInstance;
+  const config2 = getConfig();
+  clientInstance = new TaskNetClient({
+    apiUrl: config2.apiUrl,
+    apiKey: config2.apiKey,
+    network: config2.network,
+    rpcUrl: config2.rpcUrl,
+    packageId: config2.packageId,
+    walrusAggregator: config2.walrusAggregator,
+    walrusPublisher: config2.walrusPublisher,
+    agentId: config2.agentId
+  });
+  return clientInstance;
+}
+
+// src/commands/agent.ts
+function registerAgentCommands(program2) {
+  const agentCmd = program2.command("agent").description("Manage agents");
+  agentCmd.command("list").description("List all agents").option("-p, --page <number>", "Page number", "1").option("-l, --limit <number>", "Items per page", "20").action(async (options) => {
+    const spin = spinner("Fetching agents...").start();
+    try {
+      const client = getClient();
+      const result = await client.api.listAgents({
+        page: parseInt(options.page),
+        limit: parseInt(options.limit)
+      });
+      spin.stop();
+      output(result, () => {
+        const rows = result.data.map((agent) => [
+          formatAddress(agent.id),
+          formatAddress(agent.owner),
+          String(agent.skills_count),
+          String(agent.tasks_as_worker),
+          formatPercent(agent.stats?.completion_rate)
+        ]);
+        return `
+${colors.primary("Agents")} (${result.pagination.total} total)
+
+` + table(["ID", "Owner", "Skills", "Tasks Done", "Success"], rows) + `
+
+Page ${result.pagination.page}/${result.pagination.pages}`;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Failed to list agents: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  agentCmd.command("info [id]").description("Get agent details (uses configured agent if no ID)").action(async (id) => {
+    const agentId = id ?? getConfig().agentId;
+    if (!agentId) {
+      error("No agent ID provided. Set one with: tasknet config set agentId <id>");
+      process.exit(1);
+    }
+    const spin = spinner("Fetching agent...").start();
+    try {
+      const client = getClient();
+      const agent = await client.api.getAgent(agentId);
+      spin.stop();
+      output(agent, () => {
+        let output2 = `
+${colors.primary("Agent Details")}
+
+`;
+        output2 += `${colors.muted("ID:")}          ${agent.id}
+`;
+        output2 += `${colors.muted("Owner:")}       ${agent.owner}
+`;
+        output2 += `${colors.muted("Created:")}     ${formatTimestamp(agent.created_at)}
+`;
+        output2 += `${colors.muted("Metadata:")}    ${agent.metadata_uri ?? "(none)"}
+`;
+        if (agent.skills.length > 0) {
+          output2 += `
+${colors.primary("Skills")} (${agent.skills.length})
+
+`;
+          const skillRows = agent.skills.map((s) => [
+            s.name,
+            s.version,
+            formatUsdc(s.base_price_usdc)
+          ]);
+          output2 += table(["Name", "Version", "Price"], skillRows);
+        }
+        if (agent.badges.length > 0) {
+          output2 += `
+
+${colors.primary("Badges")} (${agent.badges.length})
+
+`;
+          const badgeRows = agent.badges.map((b) => [
+            b.badge_type,
+            `Tier ${b.tier}`,
+            formatTimestamp(b.earned_at)
+          ]);
+          output2 += table(["Type", "Tier", "Earned"], badgeRows);
+        }
+        return output2;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Failed to get agent: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  agentCmd.command("stats [id]").description("Get agent statistics").action(async (id) => {
+    const agentId = id ?? getConfig().agentId;
+    if (!agentId) {
+      error("No agent ID provided");
+      process.exit(1);
+    }
+    const spin = spinner("Fetching stats...").start();
+    try {
+      const client = getClient();
+      const stats = await client.api.getAgentStats(agentId);
+      spin.stop();
+      output(stats, () => {
+        let output2 = `
+${colors.primary("Agent Statistics")}
+
+`;
+        output2 += `${colors.highlight("Worker Stats")}
+`;
+        output2 += `  Tasks Completed:  ${stats.workerTasksCompleted}
+`;
+        output2 += `  Tasks Failed:     ${stats.workerTasksFailed}
+`;
+        output2 += `  Tasks Expired:    ${stats.workerTasksExpired}
+`;
+        output2 += `  Total Earned:     ${formatUsdc(stats.workerTotalEarnedUsdc)}
+`;
+        output2 += `  Completion Rate:  ${formatPercent(stats.completionRate)}
+`;
+        output2 += `
+${colors.highlight("Requester Stats")}
+`;
+        output2 += `  Tasks Posted:     ${stats.requesterTasksPosted}
+`;
+        output2 += `  Tasks Settled:    ${stats.requesterTasksSettled}
+`;
+        output2 += `  Tasks Cancelled:  ${stats.requesterTasksCancelled}
+`;
+        output2 += `  Tasks Rejected:   ${stats.requesterTasksRejected}
+`;
+        output2 += `  Total Spent:      ${formatUsdc(stats.requesterTotalSpentUsdc)}
+`;
+        output2 += `  Rejection Rate:   ${formatPercent(stats.rejectionRate)}
+`;
+        output2 += `
+${colors.highlight("Metrics")}
+`;
+        output2 += `  Unique Partners:  ${stats.uniqueCounterparties}
+`;
+        output2 += `  Flagged:          ${stats.flaggedForAbuse ? colors.error("Yes") : colors.success("No")}
+`;
+        return output2;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Failed to get stats: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  agentCmd.command("use <id>").description("Set the current agent for commands").option("-n, --name <name>", "Agent name for display").action((id, options) => {
+    setConfig("agentId", id);
+    if (options.name) {
+      setConfig("agentName", options.name);
+    }
+    success(`Now using agent: ${formatAddress(id)}`);
+  });
+  agentCmd.command("current").description("Show current agent").action(() => {
+    const config2 = getConfig();
+    if (!config2.agentId) {
+      log("No agent configured. Use: tasknet agent use <id>");
+      return;
+    }
+    log(`
+Current Agent:`);
+    log(`  ID:   ${config2.agentId}`);
+    if (config2.agentName) {
+      log(`  Name: ${config2.agentName}`);
+    }
+    log("");
+  });
+}
+
+// src/commands/skill.ts
+function registerSkillCommands(program2) {
+  const skillCmd = program2.command("skill").alias("skills").description("Manage skills");
+  skillCmd.command("list").description("List available skills").option("-p, --page <number>", "Page number", "1").option("-l, --limit <number>", "Items per page", "20").option("-n, --name <name>", "Filter by name").option("-a, --agent <id>", "Filter by agent ID").option("-v, --verification <type>", "Filter by verification type (0-2)").option("--deprecated", "Include deprecated skills").option("-s, --sort <field>", "Sort by: published_at, name, price", "published_at").option("-o, --order <dir>", "Sort order: asc, desc", "desc").action(async (options) => {
+    const spin = spinner("Fetching skills...").start();
+    try {
+      const client = getClient();
+      const result = await client.api.listSkills({
+        page: parseInt(options.page),
+        limit: parseInt(options.limit),
+        name: options.name,
+        agentId: options.agent,
+        verificationType: options.verification ? parseInt(options.verification) : void 0,
+        includeDeprecated: options.deprecated,
+        sortBy: options.sort,
+        sortOrder: options.order
+      });
+      spin.stop();
+      output(result, () => {
+        const rows = result.data.map((skill) => [
+          skill.name,
+          skill.version,
+          formatUsdc(skill.base_price_usdc),
+          skill.verification_type_label,
+          formatDuration(skill.timeout_seconds),
+          String(skill.tasks_count)
+        ]);
+        return `
+${colors.primary("Skills")} (${result.pagination.total} total)
+
+` + table(["Name", "Version", "Price", "Verification", "Timeout", "Tasks"], rows) + `
+
+Page ${result.pagination.page}/${result.pagination.pages}`;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Failed to list skills: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  skillCmd.command("info <id>").description("Get skill details").action(async (id) => {
+    const spin = spinner("Fetching skill...").start();
+    try {
+      const client = getClient();
+      const skill = await client.api.getSkill(id);
+      spin.stop();
+      output(skill, () => {
+        let output2 = `
+${colors.primary("Skill Details")}
+
+`;
+        output2 += `${colors.muted("ID:")}              ${skill.id}
+`;
+        output2 += `${colors.muted("Name:")}            ${skill.name}
+`;
+        output2 += `${colors.muted("Version:")}         ${skill.version}
+`;
+        output2 += `${colors.muted("Agent:")}           ${formatAddress(skill.agent.id)}
+`;
+        output2 += `${colors.muted("Price:")}           ${formatUsdc(skill.base_price_usdc)}
+`;
+        output2 += `${colors.muted("Worker Bond:")}     ${formatUsdc(skill.worker_bond_usdc)}
+`;
+        output2 += `${colors.muted("Verification:")}    ${skill.verification_type_label}
+`;
+        output2 += `${colors.muted("Timeout:")}         ${formatDuration(skill.timeout_seconds)}
+`;
+        output2 += `${colors.muted("Published:")}       ${formatTimestamp(skill.published_at)}
+`;
+        output2 += `${colors.muted("Deprecated:")}      ${skill.deprecated ? colors.error("Yes") : colors.success("No")}
+`;
+        if (skill.input_schema_hash) {
+          output2 += `${colors.muted("Input Schema:")}    ${skill.input_schema_hash.slice(0, 16)}...
+`;
+        }
+        if (skill.output_schema_hash) {
+          output2 += `${colors.muted("Output Schema:")}   ${skill.output_schema_hash.slice(0, 16)}...
+`;
+        }
+        output2 += `
+${colors.primary("Priority Multipliers")}
+`;
+        const multipliers = skill.priority_multipliers;
+        output2 += `  Standard: ${(multipliers[0] / 1e4).toFixed(1)}x
+`;
+        output2 += `  Priority: ${(multipliers[1] / 1e4).toFixed(1)}x
+`;
+        output2 += `  Urgent:   ${(multipliers[2] / 1e4).toFixed(1)}x
+`;
+        output2 += `
+${colors.primary("Statistics")}
+`;
+        output2 += `  Total Tasks: ${skill.stats.total_tasks}
+`;
+        output2 += `  Templates:   ${skill.stats.templates_count}
+`;
+        if (Object.keys(skill.stats.tasks_by_status).length > 0) {
+          output2 += `
+  ${colors.highlight("Tasks by Status:")}
+`;
+          for (const [status, count] of Object.entries(skill.stats.tasks_by_status)) {
+            output2 += `    ${status}: ${count}
+`;
+          }
+        }
+        if (skill.certifications.length > 0) {
+          output2 += `
+${colors.primary("Certifications")} (${skill.certifications.length})
+
+`;
+          const certRows = skill.certifications.map((c) => [
+            c.certification_type,
+            formatAddress(c.certifier_id),
+            formatTimestamp(c.certified_at)
+          ]);
+          output2 += table(["Type", "Certifier", "Certified"], certRows);
+        }
+        return output2;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Failed to get skill: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  skillCmd.command("search <query>").description("Search skills by name").option("-l, --limit <number>", "Max results", "10").action(async (query, options) => {
+    const spin = spinner("Searching...").start();
+    try {
+      const client = getClient();
+      const result = await client.api.listSkills({
+        name: query,
+        limit: parseInt(options.limit)
+      });
+      spin.stop();
+      if (result.data.length === 0) {
+        log(`
+No skills found matching "${query}"
+`);
+        return;
+      }
+      output(result, () => {
+        const rows = result.data.map((skill) => [
+          skill.name,
+          skill.version,
+          formatUsdc(skill.base_price_usdc),
+          skill.verification_type_label,
+          formatAddress(skill.id)
+        ]);
+        return `
+${colors.primary("Search Results")} for "${query}"
+
+` + table(["Name", "Version", "Price", "Verification", "ID"], rows);
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Search failed: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/task.ts
+import { STATUS } from "@tasknet-protocol/shared";
+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) => {
+    const spin = spinner("Fetching tasks...").start();
+    try {
+      const client = getClient();
+      const config2 = getConfig();
+      let requesterId;
+      let workerId;
+      let status;
+      if (options.mine && config2.agentId) {
+        requesterId = config2.agentId;
+      } else {
+        requesterId = options.requester;
+        workerId = options.worker;
+      }
+      if (options.available) {
+        status = STATUS.POSTED;
+      } else if (options.status !== void 0) {
+        status = parseInt(options.status);
+      }
+      const result = await client.api.listTasks({
+        page: parseInt(options.page),
+        limit: parseInt(options.limit),
+        status,
+        skillId: options.skill,
+        requesterId,
+        workerId,
+        sortBy: options.sort,
+        sortOrder: options.order
+      });
+      spin.stop();
+      output(result, () => {
+        const rows = result.data.map((task) => [
+          formatAddress(task.id),
+          task.skill.name,
+          task.status_label,
+          task.priority_label,
+          formatUsdc(task.payment_amount_usdc),
+          formatTimestamp(task.expires_at)
+        ]);
+        return `
+${colors.primary("Tasks")} (${result.pagination.total} total)
+
+` + table(["ID", "Skill", "Status", "Priority", "Payment", "Expires"], rows) + `
+
+Page ${result.pagination.page}/${result.pagination.pages}`;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Failed to list tasks: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  taskCmd.command("info <id>").description("Get task details").action(async (id) => {
+    const spin = spinner("Fetching task...").start();
+    try {
+      const client = getClient();
+      const task = await client.api.getTask(id);
+      spin.stop();
+      output(task, () => {
+        let output2 = `
+${colors.primary("Task Details")}
+
+`;
+        output2 += `${colors.muted("ID:")}              ${task.id}
+`;
+        output2 += `${colors.muted("Skill:")}           ${task.skill.name} v${task.skill.version}
+`;
+        output2 += `${colors.muted("Status:")}          ${getStatusColor(task.status)(task.status_label)}
+`;
+        output2 += `${colors.muted("Priority:")}        ${task.priority_label}
+`;
+        output2 += `${colors.muted("Verification:")}    ${task.verification_type_label}
+`;
+        output2 += `${colors.muted("Payment:")}         ${formatUsdc(task.payment_amount_usdc)}
+`;
+        output2 += `${colors.muted("Worker Bond:")}     ${formatUsdc(task.worker_bond_amount)}
+`;
+        output2 += `
+${colors.primary("Participants")}
+`;
+        output2 += `${colors.muted("Requester:")}       ${formatAddress(task.requester.id)}
+`;
+        if (task.worker) {
+          output2 += `${colors.muted("Worker:")}          ${formatAddress(task.worker.id)}
+`;
+        }
+        output2 += `
+${colors.primary("Payload")}
+`;
+        output2 += `${colors.muted("Input Ref:")}       ${task.input_payload_ref}
+`;
+        if (task.expected_output_hash) {
+          output2 += `${colors.muted("Expected Hash:")}   ${task.expected_output_hash.slice(0, 32)}...
+`;
+        }
+        if (task.output_ref) {
+          output2 += `${colors.muted("Output Ref:")}      ${task.output_ref}
+`;
+        }
+        if (task.output_hash) {
+          output2 += `${colors.muted("Output Hash:")}     ${task.output_hash.slice(0, 32)}...
+`;
+        }
+        output2 += `
+${colors.primary("Timestamps")}
+`;
+        output2 += `${colors.muted("Created:")}         ${formatTimestamp(task.timestamps.created_at)}
+`;
+        output2 += `${colors.muted("Expires:")}         ${formatTimestamp(task.timestamps.expires_at)}
+`;
+        if (task.timestamps.reserved_at) {
+          output2 += `${colors.muted("Reserved:")}        ${formatTimestamp(task.timestamps.reserved_at)}
+`;
+        }
+        if (task.timestamps.accepted_at) {
+          output2 += `${colors.muted("Accepted:")}        ${formatTimestamp(task.timestamps.accepted_at)}
+`;
+        }
+        if (task.timestamps.submitted_at) {
+          output2 += `${colors.muted("Submitted:")}       ${formatTimestamp(task.timestamps.submitted_at)}
+`;
+        }
+        if (task.timestamps.verified_at) {
+          output2 += `${colors.muted("Verified:")}        ${formatTimestamp(task.timestamps.verified_at)}
+`;
+        }
+        if (task.timestamps.settled_at) {
+          output2 += `${colors.muted("Settled:")}         ${formatTimestamp(task.timestamps.settled_at)}
+`;
+        }
+        if (task.events.length > 0) {
+          output2 += `
+${colors.primary("Recent Events")}
+
+`;
+          const eventRows = task.events.slice(0, 5).map((e) => [
+            e.type,
+            formatTimestamp(e.timestamp_ms),
+            formatAddress(e.tx_digest)
+          ]);
+          output2 += table(["Event", "Time", "TX"], eventRows);
+        }
+        return output2;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Failed to get task: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  taskCmd.command("watch").description("Watch for new available tasks").option("--skill <id>", "Filter by skill ID").option("-i, --interval <seconds>", "Poll interval", "30").action(async (options) => {
+    log(`
+${colors.primary("Watching for tasks...")} (Ctrl+C to stop)
+`);
+    const interval = parseInt(options.interval) * 1e3;
+    let seenTasks = /* @__PURE__ */ new Set();
+    const poll = async () => {
+      try {
+        const client = getClient();
+        const result = await client.api.listTasks({
+          status: STATUS.POSTED,
+          skillId: options.skill,
+          limit: 20,
+          sortBy: "created_at",
+          sortOrder: "desc"
+        });
+        for (const task of result.data) {
+          if (!seenTasks.has(task.id)) {
+            seenTasks.add(task.id);
+            log(
+              `${colors.success("NEW")} ${task.skill.name} | ${formatUsdc(task.payment_amount_usdc)} | ${formatAddress(task.id)}`
+            );
+          }
+        }
+      } catch (err) {
+        error(`Poll failed: ${err.message}`);
+      }
+    };
+    await poll();
+    setInterval(poll, interval);
+  });
+}
+function getStatusColor(status) {
+  switch (status) {
+    case STATUS.POSTED:
+    case STATUS.RESERVED:
+      return colors.primary;
+    case STATUS.ACCEPTED:
+    case STATUS.IN_PROGRESS:
+    case STATUS.SUBMITTED:
+      return colors.warning;
+    case STATUS.VERIFIED:
+    case STATUS.SETTLED:
+      return colors.success;
+    case STATUS.CANCELLED:
+    case STATUS.EXPIRED:
+    case STATUS.FAILED:
+      return colors.error;
+    default:
+      return colors.muted;
+  }
+}
+
+// src/commands/health.ts
+function registerHealthCommand(program2) {
+  program2.command("health").description("Check API health status").action(async () => {
+    const spin = spinner("Checking health...").start();
+    try {
+      const client = getClient();
+      const health = await client.api.health();
+      spin.stop();
+      output(health, () => {
+        const statusColor = health.status === "healthy" ? colors.success : health.status === "degraded" ? colors.warning : colors.error;
+        let output2 = `
+${colors.primary("TaskNet API Health")}
+
+`;
+        output2 += `${colors.muted("Status:")}          ${statusColor(health.status.toUpperCase())}
+`;
+        output2 += `${colors.muted("API Version:")}     ${health.apiVersion}
+`;
+        output2 += `${colors.muted("Last Sync:")}       ${formatTimestamp(health.lastSyncTimestamp)}
+`;
+        output2 += `${colors.muted("Sync Age:")}        ${(health.syncAgeMs / 1e3).toFixed(0)}s
+`;
+        output2 += `${colors.muted("Blocks Behind:")}   ${health.blocksBehind}
+`;
+        output2 += `${colors.muted("Events Total:")}    ${health.eventsProcessedTotal}
+`;
+        if (health.stats) {
+          output2 += `
+${colors.primary("Statistics")}
+`;
+          output2 += `${colors.muted("Agents:")}          ${health.stats.agents}
+`;
+          output2 += `${colors.muted("Skills:")}          ${health.stats.skills}
+`;
+          output2 += `${colors.muted("Tasks:")}           ${health.stats.tasks}
+`;
+        }
+        return output2;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Health check failed: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/claim.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();
+    try {
+      const client = getClient();
+      const targetId = agentId ?? client.getAgentId();
+      if (!targetId) {
+        spin.fail("No agent specified. Use an agent ID or set an active agent.");
+        process.exit(1);
+      }
+      const agent = await client.api.getAgent(targetId);
+      spin.succeed(`Found ${agent.badges.length} badges`);
+      output(agent.badges, () => {
+        if (agent.badges.length === 0) {
+          return `
+${chalk3.yellow("No badges earned yet.")}
+Complete tasks and verify your identity to earn badges!
+`;
+        }
+        let out = `
+${colors.primary(`Badges for ${targetId.slice(0, 16)}...`)}
+
+`;
+        out += `${colors.muted("Badge".padEnd(22))}  ${colors.muted("Tier".padEnd(10))}  ${colors.muted("Earned At")}
+`;
+        out += `${colors.muted("-".repeat(22))}  ${colors.muted("-".repeat(10))}  ${colors.muted("-".repeat(20))}
+`;
+        for (const b of agent.badges) {
+          const badge2 = (getBadgeIcon(b.badge_type) + " " + formatBadgeType(b.badge_type)).padEnd(22);
+          const tier = getTierDisplay(b.tier).padEnd(10);
+          const earnedAt = new Date(b.earned_at).toLocaleDateString();
+          out += `${badge2}  ${tier}  ${earnedAt}
+`;
+        }
+        const tierCounts = { bronze: 0, silver: 0, gold: 0, platinum: 0 };
+        for (const b of agent.badges) {
+          const tierName = getTierName(b.tier);
+          if (tierName in tierCounts) {
+            tierCounts[tierName]++;
+          }
+        }
+        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}
+`;
+        return out;
+      });
+    } catch (error2) {
+      spin.fail(chalk3.red("Failed to fetch badges"));
+      const err = error2;
+      console.error(chalk3.red(err.message));
+      process.exit(1);
+    }
+  });
+  badge.command("types").description("Show available badge types and how to earn them").action(async () => {
+    let out = `
+${colors.primary("Available Badges")}
+
+`;
+    const badges = [
+      {
+        type: "verified_identity",
+        icon: "\u2713",
+        description: "Verified identity via social or wallet",
+        howToEarn: "Verify your identity using X, GitHub, or wallet signature"
+      },
+      {
+        type: "first_task",
+        icon: "\u{1F3AF}",
+        description: "Completed first task",
+        howToEarn: "Complete your first task as a worker"
+      },
+      {
+        type: "task_completer",
+        icon: "\u{1F4E6}",
+        description: "Task completion milestone",
+        howToEarn: "Complete 10/50/200 tasks for Bronze/Silver/Gold"
+      },
+      {
+        type: "reliable_worker",
+        icon: "\u2B50",
+        description: "High completion rate",
+        howToEarn: "Maintain 90%+ completion rate with 20+ tasks"
+      },
+      {
+        type: "high_earner",
+        icon: "\u{1F4B0}",
+        description: "High earnings milestone",
+        howToEarn: "Earn $100/$1K/$10K USDC total"
+      },
+      {
+        type: "task_creator",
+        icon: "\u{1F4DD}",
+        description: "Task creation milestone",
+        howToEarn: "Post 10/50/200 tasks for Bronze/Silver/Gold"
+      },
+      {
+        type: "big_spender",
+        icon: "\u{1F48E}",
+        description: "High spending milestone",
+        howToEarn: "Spend $100/$1K/$10K USDC total"
+      },
+      {
+        type: "networker",
+        icon: "\u{1F310}",
+        description: "Network growth",
+        howToEarn: "Work with 5/25/100 unique counterparties"
+      }
+    ];
+    for (const b of badges) {
+      out += `  ${b.icon} ${chalk3.bold(formatBadgeType(b.type))}
+`;
+      out += `     ${chalk3.gray(b.description)}
+`;
+      out += `     ${chalk3.cyan("How to earn:")} ${b.howToEarn}
+
+`;
+    }
+    out += `${colors.primary("Tiers")}
+`;
+    out += `  ${chalk3.hex("#CD7F32")("\u25CF")} Bronze   - Entry level
+`;
+    out += `  ${chalk3.gray("\u25CF")} Silver   - Intermediate
+`;
+    out += `  ${chalk3.yellow("\u25CF")} Gold     - Advanced
+`;
+    out += `  ${chalk3.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();
+    try {
+      const client = getClient();
+      const targetId = agentId ?? client.getAgentId();
+      if (!targetId) {
+        spin.fail("No agent specified.");
+        process.exit(1);
+      }
+      const agent = await client.api.getAgent(targetId);
+      spin.stop();
+      if (agent.badges.length === 0) {
+        console.log(chalk3.yellow("\nNo badges to showcase yet."));
+        return;
+      }
+      const byTier = {};
+      for (const b of agent.badges) {
+        if (!byTier[b.tier]) byTier[b.tier] = [];
+        byTier[b.tier].push(b);
+      }
+      let out = `
+${chalk3.bold.underline("\u{1F3C6} Badge Showcase")}
+
+`;
+      for (const tier of [3, 2, 1, 0]) {
+        const tierBadges = byTier[tier];
+        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";
+        for (const b of tierBadges) {
+          out += `  ${getBadgeIcon(b.badge_type)} ${formatBadgeType(b.badge_type)}
+`;
+        }
+        out += "\n";
+      }
+      const stats = await client.api.getAgentStats(targetId);
+      out += `${colors.primary("Agent Stats")}
+`;
+      out += `  Tasks Completed: ${stats.workerTasksCompleted}
+`;
+      out += `  Tasks Posted: ${stats.requesterTasksPosted}
+`;
+      if (stats.completionRate !== void 0) {
+        out += `  Completion Rate: ${formatPercent(stats.completionRate)}
+`;
+      }
+      console.log(out);
+    } catch (error2) {
+      spin.fail(chalk3.red("Failed to load showcase"));
+      const err = error2;
+      console.error(chalk3.red(err.message));
+      process.exit(1);
+    }
+  });
+}
+function formatBadgeType(type) {
+  return type.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function getBadgeIcon(type) {
+  const icons = {
+    verified_identity: "\u2713",
+    first_task: "\u{1F3AF}",
+    task_completer: "\u{1F4E6}",
+    reliable_worker: "\u2B50",
+    high_earner: "\u{1F4B0}",
+    task_creator: "\u{1F4DD}",
+    big_spender: "\u{1F48E}",
+    networker: "\u{1F310}",
+    fast_worker: "\u26A1",
+    top_performer: "\u{1F3C6}"
+  };
+  return icons[type] ?? "\u{1F3C5}";
+}
+function getTierName(tier) {
+  const names = ["bronze", "silver", "gold", "platinum"];
+  return names[tier] ?? "unknown";
+}
+function getTierDisplay(tier) {
+  const tierName = getTierName(tier);
+  const color = getTierColor(tier);
+  return color(tierName.charAt(0).toUpperCase() + tierName.slice(1));
+}
+function getTierColor(tier) {
+  switch (tier) {
+    case BADGE_TIER.BRONZE:
+      return chalk3.hex("#CD7F32");
+    case BADGE_TIER.SILVER:
+      return chalk3.gray;
+    case BADGE_TIER.GOLD:
+      return chalk3.yellow;
+    case 3:
+      return chalk3.magenta;
+    default:
+      return chalk3.white;
+  }
+}
+
+// src/index.ts
+var program = new Command();
+var banner = chalk4.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   
+     \u2588\u2588\u2551   \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2588\u2588\u2557 \u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D     \u2588\u2588\u2551   
+     \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.2.0").addHelpText("beforeAll", banner).option("--json", "Output as JSON").hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  if (opts.json) {
+    const config2 = getConfig();
+    process.env.TASKNET_OUTPUT_FORMAT = "json";
+  }
+});
+registerConfigCommands(program);
+registerAgentCommands(program);
+registerSkillCommands(program);
+registerTaskCommands(program);
+registerClaimCommands(program);
+registerBadgeCommands(program);
+registerHealthCommand(program);
+program.parse();
+//# sourceMappingURL=index.js.map