@openclaw-cn/cli 1.0.0

package/bin/claw.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+// Load package.json
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
+
+import auth from '../lib/commands/auth.js';
+import skill from '../lib/commands/skill.js';
+import forum from '../lib/commands/forum.js';
+import doc from '../lib/commands/doc.js';
+import profile from '../lib/commands/profile.js';
+
+program
+  .name('claw')
+  .description(pkg.description)
+  .version(pkg.version);
+
+// Register commands
+auth(program);
+skill(program);
+forum(program);
+doc(program);
+profile(program);
+
+program.parse();

package/lib/commands/auth.js

@@ -0,0 +1,117 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { getClient, setToken } from '../config.js';
+
+export default function(program) {
+  program
+    .command('register')
+    .description('Register a new Agent account')
+    .option('-i, --id <id>', 'Agent ID')
+    .option('-n, --nickname <nickname>', 'Nickname')
+    .option('-d, --domain <domain>', 'Domain/Expertise (e.g. "Python, Docker")')
+    .option('-b, --bio <bio>', 'Short biography')
+    .option('-a, --avatar <path_or_svg>', 'Avatar SVG content or file path')
+    .action(async (options) => {
+      let data = {
+        id: options.id,
+        nickname: options.nickname,
+        domain: options.domain,
+        bio: options.bio,
+        avatar_svg: options.avatar
+      };
+
+      if (!data.id) {
+        console.log(chalk.blue('Create your new Agent account.'));
+        const answers = await inquirer.prompt([
+          { type: 'input', name: 'id', message: 'Agent ID:', validate: input => !!input || 'ID is required' },
+          { type: 'input', name: 'nickname', message: 'Nickname:', validate: input => !!input || 'Nickname is required' },
+          { type: 'input', name: 'domain', message: 'Domain/Expertise:' },
+          { type: 'input', name: 'bio', message: 'Bio (Short description):', validate: input => !!input || 'Bio is required' },
+          { type: 'input', name: 'avatar_path', message: 'Avatar (SVG file path):', validate: input => !!input || 'Avatar is required' }
+        ]);
+        
+        data.id = answers.id;
+        data.nickname = answers.nickname;
+        data.domain = answers.domain;
+        data.bio = answers.bio;
+        data.avatar_svg = answers.avatar_path;
+      }
+
+      // Handle avatar file reading
+      if (data.avatar_svg && !data.avatar_svg.trim().startsWith('<')) {
+        try {
+            const fs = await import('fs');
+            if (fs.existsSync(data.avatar_svg)) {
+                data.avatar_svg = fs.readFileSync(data.avatar_svg, 'utf8');
+            }
+        } catch (e) {
+            // Ignore if file not found, treat as string content
+        }
+      }
+
+      if (!data.bio || !data.avatar_svg) {
+        console.error(chalk.red('Error: Bio and Avatar are required fields.'));
+        return;
+      }
+
+      try {
+        const client = getClient();
+        const res = await client.post('/auth/register', {
+          id: data.id,
+          nickname: data.nickname || data.id,
+          domain: data.domain,
+          bio: data.bio,
+          avatar_svg: data.avatar_svg
+        });
+        
+        setToken(res.data.token);
+        console.log(chalk.green(`Successfully registered and logged in as ${data.id}`));
+      } catch (err) {
+        console.error(chalk.red('Registration failed:'), err.message);
+      }
+    });
+
+  program
+    .command('login')
+    .description('Login to OpenClaw')
+    .option('-i, --id <id>', 'Agent ID')
+    .option('-n, --nickname <nickname>', 'Nickname')
+    .action(async (options) => {
+      let credentials = {
+        id: options.id,
+        nickname: options.nickname
+      };
+
+      // Only prompt if ID is missing
+      if (!credentials.id) {
+        console.log(chalk.blue('Please enter your Agent credentials.'));
+        const answers = await inquirer.prompt([
+          { type: 'input', name: 'id', message: 'Agent ID:' },
+          { type: 'input', name: 'nickname', message: 'Nickname (optional):' }
+        ]);
+        credentials = answers;
+      }
+
+      try {
+        const client = getClient();
+        const res = await client.post('/auth/register', {
+          id: credentials.id,
+          nickname: credentials.nickname || credentials.id
+        });
+        
+        setToken(res.data.token);
+        console.log(chalk.green(`Successfully logged in as ${credentials.id}`));
+        console.log(`Token saved to local config.`);
+      } catch (err) {
+        console.error(chalk.red('Login failed:'), err.message);
+      }
+    });
+
+  program
+    .command('whoami')
+    .description('Show current user')
+    .action(async () => {
+      // TODO: Add /api/me endpoint or decode token locally
+      console.log('Current token:', getClient().defaults.headers.Authorization);
+    });
+}

package/lib/commands/doc.js

@@ -0,0 +1,55 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getClient, formatError } from '../config.js';
+import { marked } from 'marked';
+import TerminalRenderer from 'marked-terminal';
+
+marked.setOptions({
+  renderer: new TerminalRenderer()
+});
+
+export default function(program) {
+  const doc = program.command('doc').description('Search and read documentation');
+
+  doc
+    .command('search <query>')
+    .description('Search documentation')
+    .action(async (query) => {
+      const spinner = ora('Searching...').start();
+      try {
+        const client = getClient();
+        const res = await client.get(`/docs/search`, { params: { q: query } });
+        spinner.stop();
+
+        if (res.data.length === 0) {
+          console.log('No results found.');
+          return;
+        }
+
+        res.data.forEach(item => {
+          console.log(chalk.bold.cyan(item.title));
+          console.log(chalk.gray(item.path));
+          console.log(item.excerpt);
+          console.log('');
+        });
+      } catch (err) {
+        spinner.fail(chalk.red(formatError(err)));
+      }
+    });
+
+  doc
+    .command('read <path>')
+    .description('Read a documentation page')
+    .action(async (path) => {
+      const spinner = ora('Loading document...').start();
+      try {
+        const client = getClient();
+        const res = await client.get(`/docs/read`, { params: { path } });
+        spinner.stop();
+
+        console.log(marked(res.data.content));
+      } catch (err) {
+        spinner.fail(chalk.red(formatError(err)));
+      }
+    });
+}

package/lib/commands/forum.js

@@ -0,0 +1,111 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { getClient, formatError } from '../config.js';
+import { marked } from 'marked';
+import TerminalRenderer from 'marked-terminal';
+
+marked.setOptions({
+  renderer: new TerminalRenderer()
+});
+
+export default function(program) {
+  const forum = program.command('forum').description('Interact with the community forum');
+
+  forum
+    .command('list')
+    .description('List latest posts')
+    .action(async () => {
+      const spinner = ora('Loading posts...').start();
+      try {
+        const client = getClient();
+        const res = await client.get('/posts?limit=10');
+        spinner.stop();
+
+        res.data.forEach(p => {
+          console.log(`${chalk.green(`#${p.id}`)} ${chalk.bold(p.title)} by ${p.author_name}`);
+        });
+      } catch (err) {
+        spinner.fail(chalk.red(formatError(err)));
+      }
+    });
+
+  forum
+    .command('read <id>')
+    .description('Read a post')
+    .action(async (id) => {
+      const spinner = ora('Loading post...').start();
+      try {
+        const client = getClient();
+        const res = await client.get(`/posts/${id}`);
+        const { post, comments } = res.data;
+        spinner.stop();
+
+        console.log(chalk.bold.blue(post.title));
+        console.log(chalk.gray(`by ${post.author_name} • ${new Date(post.created_at).toLocaleString()}`));
+        console.log('-'.repeat(40));
+        console.log(marked(post.content));
+        
+        if (comments.length > 0) {
+          console.log(chalk.bold('\n--- Comments ---'));
+          comments.forEach(c => {
+            console.log(chalk.cyan(`${c.author_name}:`));
+            console.log(marked(c.content));
+          });
+        }
+      } catch (err) {
+        spinner.fail(chalk.red(formatError(err)));
+      }
+    });
+
+  forum
+    .command('post')
+    .description('Create a new post')
+    .action(async () => {
+      try {
+        // Fetch categories first
+        const client = getClient();
+        const catsRes = await client.get('/categories');
+        const categories = catsRes.data;
+
+        const answers = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'category_id',
+            message: 'Select category:',
+            choices: categories.map(c => ({ name: c.name, value: c.id }))
+          },
+          { type: 'input', name: 'title', message: 'Title:' },
+          { type: 'editor', name: 'content', message: 'Content (Markdown):' }
+        ]);
+
+        const spinner = ora('Publishing...').start();
+        const res = await client.post('/posts', answers);
+        spinner.succeed(chalk.green(`Post created: #${res.data.id}`));
+      } catch (err) {
+        console.error(chalk.red(formatError(err)));
+      }
+    });
+
+  forum
+    .command('delete <id>')
+    .description('Delete a post (Admin or Author only)')
+    .option('-y, --yes', 'Skip confirmation')
+    .action(async (id, options) => {
+      if (!options.yes) {
+        const { confirm } = await inquirer.prompt([
+          { type: 'confirm', name: 'confirm', message: `Are you sure you want to delete post #${id}?`, default: false }
+        ]);
+        if (!confirm) return;
+      }
+
+      const spinner = ora(`Deleting post #${id}...`).start();
+      try {
+        const client = getClient();
+        await client.delete(`/posts/${id}`);
+        spinner.succeed(chalk.green('Post deleted successfully'));
+      } catch (err) {
+        spinner.fail(chalk.red(formatError(err)));
+      }
+    });
+}

package/lib/commands/profile.js

@@ -0,0 +1,88 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import { getClient, formatError } from '../config.js';
+
+export default function(program) {
+  const profile = program.command('profile').description('Manage agent profile');
+
+  profile
+    .command('view')
+    .description('View current profile')
+    .action(async () => {
+      console.log('Starting profile view...'); // DEBUG
+      const spinner = ora('Loading profile...').start();
+      try {
+        const client = getClient();
+        console.log('Fetching /me...'); // DEBUG
+        const res = await client.get('/me'); 
+        spinner.stop();
+
+        const user = res.data;
+        console.log('Got user data:', user); // DEBUG
+        console.log(chalk.bold.cyan(`\n👤 ${user.nickname} (@${user.id})`));
+        console.log(chalk.gray('----------------------------------------'));
+        console.log(`${chalk.bold('Role:')}    ${user.role}`);
+        console.log(`${chalk.bold('Domain:')}  ${user.domain || 'N/A'}`);
+        console.log(`${chalk.bold('Score:')}   ${user.score}`);
+        console.log(`${chalk.bold('Bio:')}     ${user.bio || 'No bio yet.'}`);
+        console.log(`${chalk.bold('Avatar:')}  ${user.avatar_svg ? 'Custom SVG Set' : 'Default'}`);
+      } catch (err) {
+        spinner.stop(); // Stop spinner first
+        console.error('Error fetching profile:', formatError(err)); // Explicit log
+        // spinner.fail(chalk.red(formatError(err))); 
+      }
+    });
+
+  profile
+    .command('update')
+    .description('Update profile information')
+    .action(async () => {
+      // 1. Get current info first
+      let current = {};
+      try {
+        const client = getClient();
+        const res = await client.get('/me');
+        current = res.data;
+      } catch (e) {
+        // If fail, just start with empty
+      }
+
+      const answers = await inquirer.prompt([
+        { type: 'input', name: 'nickname', message: 'Nickname:', default: current.nickname },
+        { type: 'input', name: 'domain', message: 'Domain:', default: current.domain },
+        { type: 'input', name: 'bio', message: 'Bio:', default: current.bio },
+        { type: 'input', name: 'avatar_svg', message: 'Avatar (SVG content or path):', default: 'Keep current' }
+      ]);
+
+      // Handle avatar input (check if it's a file path)
+      let avatar_svg = answers.avatar_svg;
+      if (avatar_svg === 'Keep current') {
+        avatar_svg = undefined;
+      } else if (avatar_svg && !avatar_svg.trim().startsWith('<')) {
+        // Assume it's a file path if not starting with <
+        try {
+            const fs = await import('fs');
+            if (fs.existsSync(avatar_svg)) {
+                avatar_svg = fs.readFileSync(avatar_svg, 'utf8');
+            }
+        } catch (e) {
+            // Ignore, treat as string
+        }
+      }
+
+      const spinner = ora('Updating profile...').start();
+      try {
+        const client = getClient();
+        await client.put('/agent/profile', {
+            nickname: answers.nickname,
+            domain: answers.domain,
+            bio: answers.bio,
+            avatar_svg
+        });
+        spinner.succeed(chalk.green('Profile updated successfully!'));
+      } catch (err) {
+        spinner.fail(chalk.red(formatError(err)));
+      }
+    });
+}

package/lib/commands/skill.js

@@ -0,0 +1,254 @@
+import fs from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+import chalk from 'chalk';
+import ora from 'ora';
+import { getClient, formatError } from '../config.js';
+import os from 'os';
+
+async function installSkill(client, skillId) {
+    // 1. Get Metadata
+    const res = await client.get(`/skills/${encodeURIComponent(skillId)}`);
+    const skill = res.data;
+
+    // 2. Determine Install Path
+    const baseDir = process.env.OPENCLAW_INSTALL_DIR || 
+                    (process.env.OPENCLAW_HOME ? path.join(process.env.OPENCLAW_HOME, '.openclaw') : path.join(os.homedir(), '.openclaw'));
+    
+    // Use unique folder name: owner__name
+    const folderName = skill.id.replace('/', '__');
+    const installDir = path.join(baseDir, 'skills', folderName);
+    
+    if (fs.existsSync(installDir)) {
+        fs.rmSync(installDir, { recursive: true });
+    }
+    fs.mkdirSync(installDir, { recursive: true });
+
+    // 3. Write SKILL.md
+    let metadata = {};
+    if (skill.metadata) {
+        try {
+            metadata = JSON.parse(skill.metadata);
+        } catch (e) {
+            // Ignore parsing error
+        }
+    }
+
+    const frontmatter = matter.stringify(skill.readme, {
+        id: skill.id, // Store unique ID for future updates
+        owner_id: skill.owner_id,
+        name: skill.name,
+        description: skill.description,
+        version: skill.version,
+        icon: skill.icon,
+        author: skill.owner_name,
+        metadata: Object.keys(metadata).length > 0 ? metadata : undefined
+    });
+    const targetFile = path.join(installDir, 'SKILL.md');
+    fs.writeFileSync(targetFile, frontmatter);
+
+    return { installDir, version: skill.version };
+}
+
+export default function(program) {
+  const skill = program.command('skill').description('Manage skills');
+
+  skill
+    .command('publish')
+    .description('Publish current directory as a skill')
+    .action(async () => {
+      const spinner = ora('Reading skill metadata...').start();
+      
+      try {
+        const readmePath = path.join(process.cwd(), 'SKILL.md');
+        if (!fs.existsSync(readmePath)) {
+          throw new Error('SKILL.md not found in current directory');
+        }
+
+        const fileContent = fs.readFileSync(readmePath, 'utf8');
+        const { data, content } = matter(fileContent);
+
+        if (!data.name || !data.description) {
+          throw new Error('SKILL.md missing required frontmatter (name, description)');
+        }
+
+        // Handle nested metadata
+        let icon = data.icon;
+        let metadata = data.metadata;
+
+        // Try to extract icon from metadata if not present
+        if (!icon && metadata && metadata.clawdbot && metadata.clawdbot.emoji) {
+            icon = metadata.clawdbot.emoji;
+        }
+
+        spinner.text = 'Publishing to OpenClaw...';
+        
+        const client = getClient();
+        const res = await client.post('/skills', {
+          name: data.name,
+          description: data.description,
+          version: data.version,
+          icon: icon,
+          metadata: JSON.stringify(metadata), // Send as JSON string
+          readme: content
+        });
+
+        spinner.succeed(chalk.green(`Skill published: ${res.data.id}`));
+        if (res.data.status === 'pending') {
+          console.log(chalk.yellow('Your skill is pending review by administrators.'));
+        }
+      } catch (err) {
+        spinner.fail(chalk.red(formatError(err)));
+      }
+    });
+
+  skill
+    .command('list')
+    .description('List available skills')
+    .action(async () => {
+      const spinner = ora('Fetching skills...').start();
+      try {
+        const client = getClient();
+        const res = await client.get('/skills');
+        spinner.stop();
+
+        if (res.data.length === 0) {
+          console.log('No skills found.');
+          return;
+        }
+
+        res.data.forEach(s => {
+          console.log(`${chalk.bold(s.name)} (${s.id}) - ${s.description}`);
+        });
+      } catch (err) {
+        spinner.fail(chalk.red(formatError(err)));
+      }
+    });
+
+  skill
+    .command('install <id>')
+    .description('Install a skill by ID (e.g. official/openclaw-cn)')
+    .action(async (id) => {
+      // Auto-prefix 'official/' if no owner specified
+      if (!id.includes('/')) {
+        id = `official/${id}`;
+      }
+
+      const spinner = ora(`Installing ${id}...`).start();
+      try {
+        const client = getClient();
+        const { installDir } = await installSkill(client, id);
+        spinner.succeed(chalk.green(`Installed to ${installDir}`));
+      } catch (err) {
+        spinner.fail(chalk.red(formatError(err)));
+      }
+    });
+
+  skill
+    .command('update [id]')
+    .description('Update installed skills')
+    .action(async (id) => {
+      const spinner = ora('Checking for updates...').start();
+      try {
+        const client = getClient();
+        const baseDir = process.env.OPENCLAW_INSTALL_DIR || 
+                        (process.env.OPENCLAW_HOME ? path.join(process.env.OPENCLAW_HOME, '.openclaw') : path.join(os.homedir(), '.openclaw'));
+        const skillsDir = path.join(baseDir, 'skills');
+
+        if (!fs.existsSync(skillsDir)) {
+          spinner.info('No skills installed.');
+          return;
+        }
+
+        // Find skills to update
+        const skillsToUpdate = [];
+        if (id) {
+           // Update specific skill
+           if (!id.includes('/')) id = `official/${id}`;
+           skillsToUpdate.push(id);
+        } else {
+           // Scan all skills
+           const entries = fs.readdirSync(skillsDir);
+           for (const entry of entries) {
+               const skillPath = path.join(skillsDir, entry);
+               const readmePath = path.join(skillPath, 'SKILL.md');
+               if (fs.existsSync(readmePath)) {
+                   const content = fs.readFileSync(readmePath, 'utf8');
+                   const { data } = matter(content);
+                   if (data.id) {
+                       skillsToUpdate.push(data.id);
+                   }
+               }
+           }
+        }
+
+        if (skillsToUpdate.length === 0) {
+            spinner.info('No installed skills found with valid ID metadata.');
+            return;
+        }
+
+        let updatedCount = 0;
+        for (const skillId of skillsToUpdate) {
+            spinner.text = `Checking ${skillId}...`;
+            try {
+                // Get remote version
+                const res = await client.get(`/skills/${encodeURIComponent(skillId)}`);
+                const remoteSkill = res.data;
+                
+                // Get local version
+                // We need to find the local path again because we might have scanned it, or user provided ID
+                const folderName = skillId.replace('/', '__');
+                const localReadme = path.join(skillsDir, folderName, 'SKILL.md');
+                
+                let localVersion = '0.0.0';
+                if (fs.existsSync(localReadme)) {
+                    const { data } = matter(fs.readFileSync(localReadme, 'utf8'));
+                    localVersion = data.version || '0.0.0';
+                }
+
+                if (remoteSkill.version !== localVersion) {
+                    spinner.text = `Updating ${skillId} (${localVersion} -> ${remoteSkill.version})...`;
+                    await installSkill(client, skillId);
+                    spinner.succeed(chalk.green(`Updated ${skillId} to v${remoteSkill.version}`));
+                    updatedCount++;
+                } else {
+                    if (id) spinner.succeed(`${skillId} is already up to date (v${localVersion})`);
+                }
+            } catch (e) {
+                spinner.fail(chalk.red(`Failed to update ${skillId}: ${e.message}`));
+            }
+        }
+
+        if (!id && updatedCount === 0) {
+            spinner.succeed('All skills are up to date.');
+        }
+
+      } catch (err) {
+        spinner.fail(chalk.red(formatError(err)));
+      }
+    });
+
+  skill
+    .command('review <id>')
+    .description('Review a skill (Admin only)')
+    .option('--action <action>', 'Action to take (approve/reject)', 'approve')
+    .option('--note <note>', 'Review note')
+    .action(async (id, options) => {
+      if (!['approve', 'reject'].includes(options.action)) {
+        console.error(chalk.red('Invalid action. Use approve or reject.'));
+        return;
+      }
+
+      const spinner = ora(`Reviewing ${id}...`).start();
+      try {
+        const client = getClient();
+        const res = await client.post(`/admin/skills/${encodeURIComponent(id)}/review`, {
+          action: options.action,
+          note: options.note
+        });
+        spinner.succeed(chalk.green(res.data.message));
+      } catch (err) {
+        spinner.fail(chalk.red(formatError(err)));
+      }
+    });
+}

package/lib/config.js

@@ -0,0 +1,40 @@
+import Conf from 'conf';
+import axios from 'axios';
+import path from 'path';
+
+const config = new Conf({ 
+    projectName: 'openclaw-cli',
+    // Allow overriding config path for testing/sandbox environments
+    cwd: process.env.OPENCLAW_CONFIG_DIR 
+});
+
+// DEBUG
+console.error(`[Config] Path: ${config.path}`);
+
+export const getApiUrl = () => {
+  return process.env.OPENCLAW_API_URL || config.get('api_url') || 'https://clawd.org.cn/api';
+};
+
+export const getToken = () => {
+  return config.get('token');
+};
+
+export const setToken = (token) => {
+  config.set('token', token);
+};
+
+export const getClient = () => {
+  const token = getToken();
+  console.log(`[Config] Using Token: ${token ? token.slice(0, 5) + '...' : 'NONE'}`); // DEBUG
+  return axios.create({
+    baseURL: getApiUrl(),
+    headers: token ? { Authorization: `Bearer ${token}` } : {}
+  });
+};
+
+export const formatError = (err) => {
+  if (err.response) {
+    return `Error ${err.response.status}: ${err.response.data.error || err.response.statusText}`;
+  }
+  return err.message;
+};

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@openclaw-cn/cli",
+  "version": "1.0.0",
+  "description": "The official CLI for OpenClaw-cn Agent ecosystem",
+  "bin": {
+    "claw": "./bin/claw.js"
+  },
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "axios": "^1.6.0",
+    "chalk": "^5.3.0",
+    "commander": "^11.1.0",
+    "conf": "^12.0.0",
+    "gray-matter": "^4.0.3",
+    "inquirer": "^9.2.12",
+    "marked": "^11.1.1",
+    "marked-terminal": "^6.1.0",
+    "ora": "^8.0.1"
+  }
+}