upclaw-cli 1.0.0

package/src/commands/login.ts

@@ -0,0 +1,80 @@
+import { createWalletClient, http, parseEther } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { baseSepolia } from "viem/chains";
+import inquirer from "inquirer";
+import chalk from "chalk";
+import ora from "ora";
+import { config } from "../config";
+import { createAPIClient } from "../utils/api";
+import * as fs from "fs-extra";
+
+export async function loginCommand(options: { privateKey?: string; keystore?: string }) {
+  let privateKey: string;
+
+  // Get private key from various sources
+  if (options.privateKey) {
+    privateKey = options.privateKey;
+  } else if (options.keystore) {
+    // Load from keystore file
+    const keystoreData = await fs.readJSON(options.keystore);
+    privateKey = keystoreData.privateKey;
+  } else {
+    // Prompt for private key
+    const answers = await inquirer.prompt([
+      {
+        type: "password",
+        name: "privateKey",
+        message: "Enter your wallet private key (0x...):",
+        validate: (input) => {
+          if (!input.startsWith("0x") || input.length !== 66) {
+            return "Invalid private key format. Must be 0x followed by 64 hex characters.";
+          }
+          return true;
+        },
+      },
+    ]);
+    privateKey = answers.privateKey;
+  }
+
+  const spinner = ora("Authenticating...").start();
+
+  try {
+    // Create account from private key
+    const account = privateKeyToAccount(privateKey as `0x${string}`);
+    const address = account.address;
+
+    // Sign a message to prove ownership
+    const message = `Sign in to UpClaw CLI\nTimestamp: ${Date.now()}`;
+    const signature = await account.signMessage({ message });
+
+    // Authenticate with API
+    const api = createAPIClient();
+    const response = await api.post("/cli/auth", {
+      address,
+      signature,
+      message,
+    });
+
+    const { token, user } = response.data;
+
+    // Store credentials
+    config.set("token", token);
+    config.set("address", user.address);
+    config.set("username", user.username);
+
+    spinner.succeed(
+      chalk.green(`✓ Successfully logged in as ${chalk.bold(user.username)} (${user.address})`)
+    );
+  } catch (error: any) {
+    spinner.fail(chalk.red("Authentication failed"));
+
+    if (error.response?.status === 404) {
+      console.error(chalk.yellow("\n⚠️  User not found. Please register at https://upclaw.ai first."));
+    } else if (error.response?.data?.error) {
+      console.error(chalk.red(`\nError: ${error.response.data.error}`));
+    } else {
+      console.error(chalk.red(`\nError: ${error.message}`));
+    }
+    process.exit(1);
+  }
+}

package/src/commands/publish.ts

@@ -0,0 +1,152 @@
+import chalk from "chalk";
+import ora from "ora";
+import inquirer from "inquirer";
+import * as fs from "fs-extra";
+import * as path from "path";
+import archiver from "archiver";
+import FormData from "form-data";
+import { createAPIClient, requireAuth } from "../utils/api";
+
+interface PublishOptions {
+  name?: string;
+  description?: string;
+  category?: string;
+  price?: string;
+  version?: string;
+}
+
+export async function publishCommand(options: PublishOptions) {
+  requireAuth();
+
+  console.log(chalk.bold.cyan("\n📤 Publishing Skill to UpClaw\n"));
+
+  // Check for required files
+  const requiredFiles = ["SKILL.md", "package.json"];
+  const missingFiles = requiredFiles.filter((file) => !fs.existsSync(file));
+
+  if (missingFiles.length > 0) {
+    console.error(chalk.red(`❌ Missing required files: ${missingFiles.join(", ")}\n`));
+    console.log(chalk.gray("Your skill must include:"));
+    console.log(chalk.gray("  - SKILL.md (documentation)"));
+    console.log(chalk.gray("  - package.json (dependencies)\n"));
+    process.exit(1);
+  }
+
+  // Get metadata from user if not provided
+  let metadata = options;
+
+  if (!metadata.name || !metadata.description || !metadata.category || !metadata.price) {
+    const packageJson = await fs.readJSON("package.json");
+
+    const answers = await inquirer.prompt([
+      {
+        type: "input",
+        name: "name",
+        message: "Skill name:",
+        default: metadata.name || packageJson.name,
+        when: !metadata.name,
+      },
+      {
+        type: "input",
+        name: "description",
+        message: "Description:",
+        default: metadata.description || packageJson.description,
+        when: !metadata.description,
+      },
+      {
+        type: "list",
+        name: "category",
+        message: "Category:",
+        choices: ["automation", "data", "communication", "web", "ai", "utility", "other"],
+        when: !metadata.category,
+      },
+      {
+        type: "input",
+        name: "price",
+        message: "Price in USDC:",
+        validate: (input) => {
+          const num = parseFloat(input);
+          if (isNaN(num) || num < 0) {
+            return "Please enter a valid price (e.g., 25.00)";
+          }
+          return true;
+        },
+        when: !metadata.price,
+      },
+      {
+        type: "input",
+        name: "version",
+        message: "Version:",
+        default: metadata.version || packageJson.version || "1.0.0",
+        when: !metadata.version,
+      },
+    ]);
+
+    metadata = { ...metadata, ...answers };
+  }
+
+  const spinner = ora("Creating skill bundle...").start();
+
+  try {
+    // Create a zip of the current directory
+    const zipPath = path.join(process.cwd(), "skill-bundle.zip");
+    const output = fs.createWriteStream(zipPath);
+    const archive = archiver("zip", { zlib: { level: 9 } });
+
+    archive.pipe(output);
+    archive.glob("**/*", {
+      ignore: ["node_modules/**", "*.zip", ".git/**", "dist/**", ".env*"],
+    });
+
+    await archive.finalize();
+
+    await new Promise((resolve) => output.on("close", () => resolve(undefined)));
+
+    spinner.text = "Uploading to IPFS...";
+
+    // Upload to marketplace API
+    const api = createAPIClient();
+    const formData = new FormData();
+
+    formData.append("name", metadata.name!);
+    formData.append("description", metadata.description!);
+    formData.append("category", metadata.category!);
+    formData.append("price", metadata.price!);
+    formData.append("version", metadata.version!);
+    formData.append("files", fs.createReadStream(zipPath));
+
+    const response = await api.post("/cli/skills/publish", formData, {
+      headers: formData.getHeaders(),
+      maxContentLength: Infinity,
+      maxBodyLength: Infinity,
+    });
+
+    // Clean up
+    await fs.remove(zipPath);
+
+    spinner.succeed(chalk.green("✓ Skill uploaded successfully!"));
+
+    const { skill, message, next_steps } = response.data;
+
+    console.log(chalk.bold(`\n✨ ${metadata.name} is ready!\n`));
+    console.log(`${chalk.gray("Skill ID:")}  ${skill.id}`);
+    console.log(`${chalk.gray("IPFS CID:")} ${skill.ipfs_cid}`);
+    console.log(`${chalk.gray("Price:")}    ${chalk.green("$" + skill.price + " USDC")}\n`);
+
+    console.log(chalk.yellow(message + "\n"));
+    console.log(chalk.bold("⚡ Next Steps:\n"));
+    next_steps.forEach((step: string, i: number) => {
+      console.log(`  ${i + 1}. ${step}`);
+    });
+    console.log();
+  } catch (error: any) {
+    spinner.fail(chalk.red("Publication failed"));
+
+    if (error.response?.data?.error) {
+      console.error(chalk.red(`\nError: ${error.response.data.error}\n`));
+    } else {
+      console.error(chalk.red(`\nError: ${error.message}\n`));
+    }
+    process.exit(1);
+  }
+}

package/src/commands/search.ts

@@ -0,0 +1,56 @@
+import chalk from "chalk";
+import ora from "ora";
+import { createAPIClient } from "../utils/api";
+
+interface SearchOptions {
+  category?: string;
+  minPrice?: string;
+  maxPrice?: string;
+  limit?: string;
+}
+
+export async function searchCommand(query: string, options: SearchOptions) {
+  const spinner = ora("Searching marketplace...").start();
+
+  try {
+    const api = createAPIClient();
+    const params = new URLSearchParams({
+      q: query,
+      limit: options.limit || "20",
+    });
+
+    if (options.category) params.append("category", options.category);
+    if (options.minPrice) params.append("minPrice", options.minPrice);
+    if (options.maxPrice) params.append("maxPrice", options.maxPrice);
+
+    const response = await api.get(`/cli/skills/search?${params.toString()}`);
+    const { skills, count } = response.data;
+
+    spinner.stop();
+
+    if (skills.length === 0) {
+      console.log(chalk.yellow("\n⚠️  No skills found matching your query.\n"));
+      return;
+    }
+
+    console.log(chalk.bold(`\n🔍 Found ${count} skill${count !== 1 ? "s" : ""}\n`));
+
+    skills.forEach((skill: any) => {
+      console.log(chalk.bold.cyan(`• ${skill.name}`));
+      console.log(`  ${skill.description}`);
+      console.log(
+        `  ${chalk.gray("Category:")} ${skill.category}  ${chalk.gray("Price:")} ${chalk.green(
+          "$" + skill.price_usdc
+        )}  ${chalk.gray("⬇")} ${skill.downloads}`
+      );
+      console.log(`  ${chalk.gray("ID:")} ${skill.id}\n`);
+    });
+
+    console.log(chalk.gray(`Run 'upclaw info <skill-name>' to see more details`));
+    console.log(chalk.gray(`Run 'upclaw install <skill-name>' to purchase and install\n`));
+  } catch (error: any) {
+    spinner.fail(chalk.red("Search failed"));
+    console.error(chalk.red(`Error: ${error.message}\n`));
+    process.exit(1);
+  }
+}

package/src/commands/whoami.ts

@@ -0,0 +1,18 @@
+import chalk from "chalk";
+import { config } from "../config";
+
+export async function whoamiCommand() {
+  const token = config.get("token");
+  const address = config.get("address");
+  const username = config.get("username");
+
+  if (!token) {
+    console.log(chalk.yellow("Not authenticated. Run 'upclaw login' to sign in."));
+    return;
+  }
+
+  console.log(chalk.bold("\n🔐 Authentication Status\n"));
+  console.log(`Username: ${chalk.cyan(username)}`);
+  console.log(`Address:  ${chalk.cyan(address)}`);
+  console.log(`Status:   ${chalk.green("✓ Authenticated")}\n`);
+}

package/src/config.ts

@@ -0,0 +1,14 @@
+import Conf from "conf";
+
+interface UpClawConfig {
+  token?: string;
+  address?: string;
+  username?: string;
+}
+
+export const config = new Conf<UpClawConfig>({
+  projectName: "upclaw-cli",
+  defaults: {},
+});
+
+export const API_BASE_URL = process.env.UPCLAW_API_URL || "https://upclaw.ai/api";

package/src/index.ts

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import { searchCommand } from "./commands/search";
+import { installCommand } from "./commands/install";
+import { publishCommand } from "./commands/publish";
+import { loginCommand } from "./commands/login";
+import { whoamiCommand } from "./commands/whoami";
+import { listCommand } from "./commands/list";
+import { infoCommand } from "./commands/info";
+
+const program = new Command();
+
+program
+  .name("upclaw")
+  .description("CLI tool for UpClaw marketplace - buy and sell OpenClaw agent skills")
+  .version("1.0.0");
+
+program
+  .command("login")
+  .description("Authenticate with your wallet")
+  .option("-p, --private-key <key>", "Wallet private key (0x...)")
+  .option("-k, --keystore <file>", "Path to keystore JSON file")
+  .action(loginCommand);
+
+program
+  .command("whoami")
+  .description("Show current authentication status")
+  .action(whoamiCommand);
+
+program
+  .command("search <query>")
+  .description("Search for skills in the marketplace")
+  .option("-c, --category <category>", "Filter by category")
+  .option("--min-price <price>", "Minimum price in USDC")
+  .option("--max-price <price>", "Maximum price in USDC")
+  .option("-l, --limit <number>", "Number of results to show", "20")
+  .action(searchCommand);
+
+program
+  .command("info <skill-name>")
+  .description("View detailed information about a skill")
+  .action(infoCommand);
+
+program
+  .command("install <skill-name>")
+  .description("Purchase and install a skill")
+  .option("-o, --output <directory>", "Installation directory", process.env.HOME + "/.upclaw/skills")
+  .action(installCommand);
+
+program
+  .command("list")
+  .description("List your owned skills")
+  .option("-f, --format <format>", "Output format (table|json)", "table")
+  .action(listCommand);
+
+program
+  .command("publish")
+  .description("Publish current directory as a skill")
+  .option("-n, --name <name>", "Skill name")
+  .option("-d, --description <description>", "Skill description")
+  .option("-c, --category <category>", "Category (automation|data|communication|etc)")
+  .option("-p, --price <price>", "Price in USDC")
+  .option("-v, --version <version>", "Version number", "1.0.0")
+  .action(publishCommand);
+
+program.parse();

package/src/utils/api.ts

@@ -0,0 +1,26 @@
+import axios, { AxiosInstance } from "axios";
+import { config, API_BASE_URL } from "../config";
+
+export function createAPIClient(): AxiosInstance {
+  const token = config.get("token");
+
+  return axios.create({
+    baseURL: API_BASE_URL,
+    headers: token
+      ? {
+          Authorization: `Bearer ${token}`,
+        }
+      : {},
+  });
+}
+
+export function isAuthenticated(): boolean {
+  return !!config.get("token");
+}
+
+export function requireAuth() {
+  if (!isAuthenticated()) {
+    console.error("❌ Not authenticated. Please run 'upclaw login' first.");
+    process.exit(1);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": false,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "moduleResolution": "node",
+    "types": ["node"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "../node_modules"]
+}