clawnet 0.0.1

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "clawnet",
+  "version": "0.0.1",
+  "description": "CLI for clawhub.network - install, publish, and search agent skills on-chain",
+  "type": "module",
+  "bin": {
+    "clawnet": "./bin/clawnet.js"
+  },
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "scripts": {
+    "build": "bun build ./src/cli.ts --target=bun --outfile=bin/clawnet.js",
+    "prepublishOnly": "bun run build",
+    "lint": "biome check src/",
+    "lint:fix": "biome check --write src/"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@clawhub/sdk": "0.1.0",
+    "@types/node": "^20",
+    "chalk": "^5.4.1",
+    "typescript": "^5"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/b-open-io/clawhub.network",
+    "directory": "packages/cli"
+  },
+  "keywords": ["ai", "agent", "skills", "bsv", "blockchain", "cli"]
+}

package/src/api.ts

@@ -0,0 +1,162 @@
+import { DEFAULT_REGISTRY } from "./config.js";
+
+export class ApiError extends Error {
+  constructor(
+    public status: number,
+    message: string
+  ) {
+    super(message);
+    this.name = "ApiError";
+  }
+}
+
+async function request(
+  path: string,
+  options: RequestInit = {},
+  token?: string
+): Promise<unknown> {
+  const url = `${DEFAULT_REGISTRY}/api/v1${path}`;
+  const headers: Record<string, string> = {
+    ...(options.headers as Record<string, string>),
+  };
+
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+
+  if (options.body && !headers["Content-Type"]) {
+    headers["Content-Type"] = "application/json";
+  }
+
+  const res = await fetch(url, { ...options, headers });
+
+  if (!res.ok) {
+    if (res.status === 401) {
+      throw new ApiError(401, 'Not authenticated. Run "clawnet login" first.');
+    }
+    const body = await res.json().catch(() => ({ error: res.statusText }));
+    throw new ApiError(
+      res.status,
+      (body as { error?: string }).error || res.statusText
+    );
+  }
+
+  return res.json();
+}
+
+export interface SkillSummary {
+  slug: string;
+  name: string;
+  description: string;
+  authorBapId: string;
+  latestVersion: string;
+  latestTxId: string;
+  homepage?: string;
+  tags?: string[];
+  starCount: number;
+  downloadCount: number;
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface SkillDetail {
+  skill: SkillSummary & { deleted: boolean; downloadCountAllTime: number };
+  latestVersion: {
+    version: string;
+    txId: string;
+    content: string;
+    contentType: string;
+    changelog?: string;
+    files: { path: string; content: string }[];
+    publishedAt: number;
+    onChain: boolean;
+  } | null;
+  author: { bapId: string; pubkey: string } | null;
+}
+
+export interface SearchResult {
+  slug: string;
+  name: string;
+  description: string;
+  authorBapId: string;
+  latestVersion: string;
+  score: number;
+}
+
+export interface WhoamiResponse {
+  user: { bapId: string; pubkey: string };
+}
+
+export async function listSkills(
+  sort = "updated",
+  limit = 50,
+  cursor?: string
+): Promise<{ skills: SkillSummary[]; hasMore: boolean; cursor?: string }> {
+  const params = new URLSearchParams({ sort, limit: String(limit) });
+  if (cursor) params.set("cursor", cursor);
+  return request(`/skills?${params}`) as Promise<{
+    skills: SkillSummary[];
+    hasMore: boolean;
+    cursor?: string;
+  }>;
+}
+
+export async function getSkill(slug: string): Promise<SkillDetail> {
+  return request(`/skills/${encodeURIComponent(slug)}`) as Promise<SkillDetail>;
+}
+
+export async function searchSkills(
+  q: string,
+  limit = 20
+): Promise<{ results: SearchResult[] }> {
+  const params = new URLSearchParams({ q, limit: String(limit) });
+  return request(`/search?${params}`) as Promise<{
+    results: SearchResult[];
+  }>;
+}
+
+export async function publishSkill(
+  payload: {
+    slug: string;
+    name: string;
+    description: string;
+    version: string;
+    changelog?: string;
+    tags?: string[];
+    homepage?: string;
+    files: { path: string; content: string }[];
+  },
+  token: string
+): Promise<{ ok: boolean; slug: string; version: string }> {
+  return request(
+    "/skills",
+    { method: "POST", body: JSON.stringify(payload) },
+    token
+  ) as Promise<{ ok: boolean; slug: string; version: string }>;
+}
+
+export async function fetchWhoami(token: string): Promise<WhoamiResponse> {
+  return request("/whoami", {}, token) as Promise<WhoamiResponse>;
+}
+
+export async function starSkill(
+  slug: string,
+  token: string
+): Promise<{ ok: boolean }> {
+  return request(
+    `/stars/${encodeURIComponent(slug)}`,
+    { method: "POST" },
+    token
+  ) as Promise<{ ok: boolean }>;
+}
+
+export async function unstarSkill(
+  slug: string,
+  token: string
+): Promise<{ ok: boolean }> {
+  return request(
+    `/stars/${encodeURIComponent(slug)}`,
+    { method: "DELETE" },
+    token
+  ) as Promise<{ ok: boolean }>;
+}

package/src/auth.ts

@@ -0,0 +1,33 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+
+import { ensureConfigDir, TOKEN_PATH } from "./config.js";
+import { decrypt, encrypt } from "./crypt.js";
+
+export async function getSavedToken(): Promise<string | null> {
+  if (!existsSync(TOKEN_PATH)) return null;
+
+  const encrypted = readFileSync(TOKEN_PATH, "utf8").trim();
+  if (!encrypted) return null;
+
+  return decrypt(encrypted);
+}
+
+export async function saveToken(token: string): Promise<void> {
+  ensureConfigDir();
+  const encrypted = await encrypt(token);
+  writeFileSync(TOKEN_PATH, encrypted, { mode: 0o600 });
+}
+
+export async function clearToken(): Promise<void> {
+  if (existsSync(TOKEN_PATH)) {
+    writeFileSync(TOKEN_PATH, "", "utf8");
+  }
+}
+
+export async function requireToken(): Promise<string> {
+  const token = await getSavedToken();
+  if (!token) {
+    throw new Error('Not authenticated. Run "clawnet login" first.');
+  }
+  return token;
+}

package/src/cli.ts

@@ -0,0 +1,149 @@
+#!/usr/bin/env bun
+
+import { info } from "./commands/info.js";
+import { install } from "./commands/install.js";
+import { login } from "./commands/login.js";
+import { logout } from "./commands/logout.js";
+import { publish } from "./commands/publish.js";
+import { search } from "./commands/search.js";
+import { star, unstar } from "./commands/star.js";
+import { whoami } from "./commands/whoami.js";
+
+const args = process.argv.slice(2);
+const command = args[0];
+const rest = args.slice(1);
+
+function printHelp() {
+  console.log(`
+clawnet - On-chain skill registry for AI agents
+
+Usage:
+  clawnet <command> [options]
+
+Commands:
+  login              Authenticate with Sigma Auth
+  logout             Clear saved credentials
+  whoami             Show current identity
+
+  publish [path]     Publish a skill from a directory (default: .)
+  install <slug>     Install a skill to agent skill directories
+  search <query>     Search for skills
+  info <slug>        Show skill details
+
+  star <slug>        Star a skill
+  unstar <slug>      Unstar a skill
+
+Options:
+  --help, -h         Show this help message
+  --version, -v      Show version
+
+Registry: https://clawhub.network
+`);
+}
+
+function printVersion() {
+  console.log("clawnet 0.0.1");
+}
+
+async function main() {
+  if (
+    !command ||
+    command === "help" ||
+    command === "--help" ||
+    command === "-h"
+  ) {
+    printHelp();
+    process.exit(0);
+  }
+
+  if (command === "--version" || command === "-v") {
+    printVersion();
+    process.exit(0);
+  }
+
+  switch (command) {
+    case "login":
+      await login();
+      break;
+
+    case "logout":
+      await logout();
+      break;
+
+    case "whoami":
+      await whoami();
+      break;
+
+    case "publish":
+      await publish(rest[0]);
+      break;
+
+    case "install": {
+      const slug = rest[0];
+      if (!slug) {
+        console.error("Error: Missing slug argument");
+        console.error("Usage: clawnet install <slug>");
+        process.exit(1);
+      }
+      const version = rest.includes("--version")
+        ? rest[rest.indexOf("--version") + 1]
+        : undefined;
+      await install(slug, version);
+      break;
+    }
+
+    case "search": {
+      const query = rest.join(" ");
+      if (!query) {
+        console.error("Error: Missing search query");
+        console.error("Usage: clawnet search <query>");
+        process.exit(1);
+      }
+      await search(query);
+      break;
+    }
+
+    case "info": {
+      const slug = rest[0];
+      if (!slug) {
+        console.error("Error: Missing slug argument");
+        console.error("Usage: clawnet info <slug>");
+        process.exit(1);
+      }
+      await info(slug);
+      break;
+    }
+
+    case "star": {
+      const slug = rest[0];
+      if (!slug) {
+        console.error("Error: Missing slug argument");
+        console.error("Usage: clawnet star <slug>");
+        process.exit(1);
+      }
+      await star(slug);
+      break;
+    }
+
+    case "unstar": {
+      const slug = rest[0];
+      if (!slug) {
+        console.error("Error: Missing slug argument");
+        console.error("Usage: clawnet unstar <slug>");
+        process.exit(1);
+      }
+      await unstar(slug);
+      break;
+    }
+
+    default:
+      console.error(`Unknown command: ${command}`);
+      printHelp();
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error("Error:", err.message);
+  process.exit(1);
+});

package/src/commands/info.ts

@@ -0,0 +1,14 @@
+import { getSkill } from "../api.js";
+import { formatError, formatSkillDetail } from "../format.js";
+
+export async function info(slug: string): Promise<void> {
+  try {
+    const data = await getSkill(slug);
+    console.log(formatSkillDetail(data));
+  } catch (err) {
+    console.error(
+      formatError(err instanceof Error ? err.message : String(err))
+    );
+    process.exit(1);
+  }
+}

package/src/commands/install.ts

@@ -0,0 +1,66 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { getSkill } from "../api.js";
+import { formatError, formatSuccess } from "../format.js";
+
+const SKILL_DIRS = [".claude/skills", ".cursor/skills", ".gemini/skills"];
+
+function detectTargetDir(): string {
+  for (const dir of SKILL_DIRS) {
+    if (existsSync(dir)) {
+      return dir;
+    }
+  }
+  return ".claude/skills";
+}
+
+export async function install(slug: string, version?: string): Promise<void> {
+  try {
+    const data = await getSkill(slug);
+
+    if (!data.latestVersion) {
+      console.error(formatError(`No published version found for ${slug}.`));
+      process.exit(1);
+    }
+
+    if (version && data.latestVersion.version !== version) {
+      console.error(
+        formatError(
+          `Version ${version} not found. Latest is ${data.latestVersion.version}.`
+        )
+      );
+      process.exit(1);
+    }
+
+    const targetDir = detectTargetDir();
+    const skillDir = join(targetDir, slug);
+    mkdirSync(skillDir, { recursive: true });
+
+    if (data.latestVersion.files && data.latestVersion.files.length > 0) {
+      for (const file of data.latestVersion.files) {
+        const filePath = join(skillDir, file.path);
+        const fileDir = join(filePath, "..");
+        mkdirSync(fileDir, { recursive: true });
+        writeFileSync(filePath, file.content, "utf8");
+      }
+    } else if (data.latestVersion.content) {
+      writeFileSync(
+        join(skillDir, "SKILL.md"),
+        data.latestVersion.content,
+        "utf8"
+      );
+    }
+
+    console.log(
+      formatSuccess(
+        `Installed ${slug}@${data.latestVersion.version} to ${skillDir}`
+      )
+    );
+  } catch (err) {
+    console.error(
+      formatError(err instanceof Error ? err.message : String(err))
+    );
+    process.exit(1);
+  }
+}

package/src/commands/login.ts

@@ -0,0 +1,116 @@
+import { execSync } from "node:child_process";
+import { saveToken } from "../auth.js";
+import { SIGMA_AUTH_URL, SIGMA_CLIENT_ID } from "../config.js";
+import { formatError, formatSuccess } from "../format.js";
+
+function openBrowser(url: string): void {
+  const cmd =
+    process.platform === "darwin"
+      ? "open"
+      : process.platform === "win32"
+        ? "start"
+        : "xdg-open";
+
+  try {
+    execSync(`${cmd} "${url}"`, { stdio: "ignore" });
+  } catch {
+    console.log(`Open this URL in your browser:\n  ${url}`);
+  }
+}
+
+interface DeviceResponse {
+  device_code: string;
+  user_code: string;
+  verification_uri: string;
+  verification_uri_complete?: string;
+  expires_in: number;
+  interval: number;
+}
+
+interface TokenResponse {
+  access_token: string;
+  token_type: string;
+  expires_in?: number;
+  error?: string;
+  error_description?: string;
+}
+
+export async function login(): Promise<void> {
+  console.log("Starting Sigma Auth device flow...\n");
+
+  const deviceRes = await fetch(`${SIGMA_AUTH_URL}/api/auth/device/code`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      client_id: SIGMA_CLIENT_ID,
+      scope: "openid profile",
+    }),
+  });
+
+  if (!deviceRes.ok) {
+    const text = await deviceRes.text();
+    console.error(formatError(`Device authorization failed: ${text}`));
+    process.exit(1);
+  }
+
+  const device: DeviceResponse = await deviceRes.json();
+  const verifyUrl =
+    device.verification_uri_complete ||
+    `${device.verification_uri}?user_code=${device.user_code}`;
+
+  console.log(`Go to: ${device.verification_uri}`);
+  console.log(`Enter code: ${device.user_code}\n`);
+
+  openBrowser(verifyUrl);
+
+  console.log("Waiting for authorization...");
+
+  let pollInterval = (device.interval || 5) * 1000;
+  const deadline = Date.now() + device.expires_in * 1000;
+
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, pollInterval));
+
+    const tokenRes = await fetch(`${SIGMA_AUTH_URL}/api/auth/device/token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        device_code: device.device_code,
+        client_id: SIGMA_CLIENT_ID,
+      }),
+    });
+
+    const tokenData: TokenResponse = await tokenRes.json();
+
+    if (tokenData.access_token) {
+      await saveToken(tokenData.access_token);
+      console.log(formatSuccess("Logged in."));
+      return;
+    }
+
+    if (tokenData.error === "authorization_pending") {
+      continue;
+    }
+
+    if (tokenData.error === "slow_down") {
+      pollInterval += 5000;
+      continue;
+    }
+
+    if (tokenData.error === "expired_token") {
+      console.error(formatError("Authorization expired. Please try again."));
+      process.exit(1);
+    }
+
+    if (tokenData.error) {
+      console.error(
+        formatError(tokenData.error_description || tokenData.error)
+      );
+      process.exit(1);
+    }
+  }
+
+  console.error(formatError("Authorization timed out. Please try again."));
+  process.exit(1);
+}

package/src/commands/logout.ts

@@ -0,0 +1,6 @@
+import { clearToken } from "../auth.js";
+
+export async function logout(): Promise<void> {
+  await clearToken();
+  console.log("Logged out.");
+}

package/src/commands/publish.ts

@@ -0,0 +1,126 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { isAbsolute, join, relative } from "node:path";
+
+import { parseSkillFrontmatter, validateSkillContent } from "@clawhub/sdk";
+import { publishSkill } from "../api.js";
+import { requireToken } from "../auth.js";
+import { formatError, formatSuccess } from "../format.js";
+
+const SKIP_DIRS = new Set(["node_modules", ".git", ".DS_Store", "__pycache__"]);
+const BINARY_EXTS = new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".ico",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".exe",
+  ".bin",
+]);
+
+function collectFiles(
+  dir: string,
+  base: string
+): { path: string; content: string }[] {
+  const files: { path: string; content: string }[] = [];
+
+  for (const entry of readdirSync(dir)) {
+    if (SKIP_DIRS.has(entry)) continue;
+    if (entry.startsWith(".")) continue;
+
+    const fullPath = join(dir, entry);
+    const stat = statSync(fullPath);
+
+    if (stat.isDirectory()) {
+      files.push(...collectFiles(fullPath, base));
+    } else if (stat.isFile()) {
+      const ext = entry.slice(entry.lastIndexOf(".")).toLowerCase();
+      if (BINARY_EXTS.has(ext)) continue;
+      if (stat.size > 1024 * 1024) continue;
+
+      const relPath = relative(base, fullPath);
+      const content = readFileSync(fullPath, "utf8");
+      files.push({ path: relPath, content });
+    }
+  }
+
+  return files;
+}
+
+export async function publish(path?: string): Promise<void> {
+  const token = await requireToken();
+  const dir = path
+    ? isAbsolute(path)
+      ? path
+      : join(process.cwd(), path)
+    : process.cwd();
+
+  if (!existsSync(dir) || !statSync(dir).isDirectory()) {
+    console.error(formatError(`Not a directory: ${dir}`));
+    process.exit(1);
+  }
+
+  const skillMdPath = existsSync(join(dir, "SKILL.md"))
+    ? join(dir, "SKILL.md")
+    : existsSync(join(dir, "skill.md"))
+      ? join(dir, "skill.md")
+      : null;
+
+  if (!skillMdPath) {
+    console.error(formatError("No SKILL.md found in directory."));
+    process.exit(1);
+  }
+
+  const skillContent = readFileSync(skillMdPath, "utf8");
+  const validation = validateSkillContent(skillContent);
+
+  if (!validation.valid) {
+    console.error(formatError("Invalid SKILL.md:"));
+    for (const e of validation.errors) {
+      console.error(`  - ${e}`);
+    }
+    process.exit(1);
+  }
+
+  const frontmatter = parseSkillFrontmatter(skillContent);
+  if (!frontmatter.success) {
+    console.error(
+      formatError(`Failed to parse frontmatter: ${frontmatter.error}`)
+    );
+    process.exit(1);
+  }
+
+  const { name, description, version } = frontmatter.data;
+  const slug = name;
+
+  console.log(`Publishing ${slug}@${version}...`);
+
+  const files = collectFiles(dir, dir);
+
+  try {
+    const result = await publishSkill(
+      {
+        slug,
+        name,
+        description,
+        version,
+        tags: frontmatter.data.tags,
+        homepage: frontmatter.data.homepage,
+        files,
+      },
+      token
+    );
+    console.log(formatSuccess(`Published ${result.slug}@${result.version}`));
+  } catch (err) {
+    console.error(
+      formatError(err instanceof Error ? err.message : String(err))
+    );
+    process.exit(1);
+  }
+}