aisoulhub 1.0.11 → 1.1.4

package/README.md

@@ -1,35 +1,57 @@
 # AISoulHub CLI
 
-A command-line interface tool to easily install, update, and manage AI Soul configurations and skills for OpenClaw agents. It seamlessly integrates with [AISoulHub](https://aisoulhub.com) to provide a streamlined experience.
+`aisoulhub` 是一个用于安装 aisoul 的命令行工具，可将 aisoul 安装到本地 OpenClaw workspace 中。
 
-## Prerequisites
+## 环境要求
 
-Before using this tool, ensure you have the following installed:
+- [Node.js](https://nodejs.org/) v16 或更高版本
+- 已安装并可直接执行的 `openclaw`
+- 可通过 `npx` 执行 `clawhub`
 
-- [Node.js](https://nodejs.org/) (v16 or higher recommended)
-- [OpenClaw](https://openclaw.ai/) CLI (`openclaw` command must be available in your PATH)
+## 使用方式
 
-## Usage
+### 安装 aisoul
 
-You can run `aisoulhub` directly via `npx` without needing to install it globally.
+```bash
+npx aisoulhub install <slug[@version]> --user <your@email.com>
+```
+
+示例：
+
+```bash
+npx aisoulhub install helloworld --user your@gmail.com
+```
 
-### 1. Install an AI Soul
+指定版本：
 
-Downloads and installs an AI Soul package into a new or existing OpenClaw Agent.
+```bash
+npx aisoulhub install helloworld@1.0.2 --user your@gmail.com
+```
+
+使用自定义服务地址：
 
 ```bash
-npx aisoulhub install <ai_soul_id>
+npx aisoulhub install helloworld --user your@gmail.com --base_url=https://aisoulhub.com
 ```
 
-### 2. Update an AI Soul
+参数说明：
+
+- `<slug[@version]>`：aisoul 标识，`@version` 可选
+- `--user`：请使用你的注册邮箱
+- `--base_url`：可选，自定义服务地址
+
+安装提示：
+
+- 如果未指定版本，将自动安装该 aisoul 的最新版本
+- 如果已存在同名 agent，请先执行 `openclaw agents delete <agentName>` 后再重新安装
 
-Updates an existing OpenClaw Agent with the latest AI Soul package configuration and skills.
+### 更新 aisoul
 
 ```bash
 npx aisoulhub update
 ```
 
-<br />
+`update` 命令已预留，当前版本暂未实现。
 
 ## License
 

package/bin/aisoulhub.js

@@ -3,6 +3,10 @@
 import { main } from '../src/index.js';
 
 main().catch(err => {
-  console.error(err);
+  if (err && typeof err === 'object' && err.userFacing) {
+    console.error(err.message);
+  } else {
+    console.error(err);
+  }
   process.exit(1);
 });

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "aisoulhub",
-  "version": "1.0.11",
+  "version": "1.1.4",
   "description": "",
-  "main": "index.js",
+  "main": "./src/index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "node ./test/install.test.js",
     "release": "npm version patch && npm publish --access public"
   },
   "files": [
@@ -22,7 +22,6 @@
   },
   "type": "module",
   "dependencies": {
-    "@inquirer/prompts": "^8.3.2",
     "chalk": "^5.6.2",
     "clawhub": "^0.9.0",
     "commander": "^14.0.3",

package/src/index.js

@@ -1,30 +1,601 @@
 import { Command } from 'commander';
-import { installCommand } from './commands/install.js';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
+import crypto from 'node:crypto';
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import { createReadStream, createWriteStream } from 'node:fs';
+import http from 'node:http';
+import https from 'node:https';
+import os from 'node:os';
+import path from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import unzipper from 'unzipper';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+export const DEFAULT_BASE_URL = 'https://aisoulhub.com';
+const CLAWHUB_REGISTRY = 'https://cn.clawhub-mirror.com';
 
-export async function main() {
-  const pkgPath = path.join(__dirname, '../package.json');
-  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+export class UserFacingError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'UserFacingError';
+    this.userFacing = true;
+  }
+}
+
+export function normalizeBaseUrl(baseUrl) {
+  return String(baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '');
+}
+
+export function buildRequestHeaders(user) {
+  const email = String(user || '').trim();
+  return email ? { 'X-USER-EMAIL': email } : {};
+}
+
+export function buildBaseUrlCandidates(baseUrl) {
+  const normalized = normalizeBaseUrl(baseUrl);
+  if (normalized.endsWith('/sc')) {
+    return [normalized];
+  }
+
+  return [normalized, `${normalized}/sc`];
+}
+
+export function parseSoulSpecifier(input) {
+  const value = String(input || '').trim();
+  const atIndex = value.lastIndexOf('@');
+
+  if (!value) {
+    throw new Error('请提供要安装的 aisoul 标识，例如 demo-soul 或 demo-soul@1.0.0');
+  }
+
+  if (atIndex <= 0) {
+    return { slug: value, version: null };
+  }
+
+  const slug = value.slice(0, atIndex).trim();
+  const version = value.slice(atIndex + 1).trim();
+
+  if (!slug || !version) {
+    throw new Error('aisoul 标识格式无效，请使用 slug 或 slug@version');
+  }
+
+  return { slug, version };
+}
+
+export function findExistingAgent(agents, agentName) {
+  if (!Array.isArray(agents)) {
+    return null;
+  }
+
+  return (
+    agents.find(agent => agent?.id === agentName || agent?.name === agentName) || null
+  );
+}
+
+export function normalizeSkillName(skill) {
+  const rawValue = String(skill || '').trim();
+  if (!rawValue) {
+    return '';
+  }
+
+  if (!rawValue.includes('/')) {
+    return rawValue;
+  }
+
+  return rawValue.split('/').filter(Boolean).pop() || '';
+}
+
+export function extractMd5Hash(content) {
+  const match = String(content || '').match(/\b([a-fA-F0-9]{32})\b/);
+  if (!match) {
+    throw new Error('无法解析远端返回的 MD5 校验码');
+  }
+
+  return match[1].toLowerCase();
+}
+
+export function buildMergedAgentsContent(existingContent, incomingContent) {
+  const incoming = String(incomingContent || '')
+    .replace(/^\uFEFF/, '')
+    .replace(/\s*$/, '');
+  if (!incoming) {
+    return String(existingContent || '');
+  }
+
+  const existing = String(existingContent || '');
+  const prefix = existing ? `${existing.replace(/\s*$/, '\n')}` : '';
+  return `${prefix}---\n${incoming}\n`;
+}
+
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function request(url, { headers = {}, redirectCount = 0 } = {}) {
+  if (redirectCount > 5) {
+    return Promise.reject(new Error(`请求重定向次数过多: ${url}`));
+  }
+
+  const parsedUrl = new URL(url);
+  const client = parsedUrl.protocol === 'https:' ? https : http;
+
+  return new Promise((resolve, reject) => {
+    const req = client.get(
+      parsedUrl,
+      {
+        headers,
+      },
+      res => {
+      const { statusCode = 0, headers } = res;
+
+      if ([301, 302, 303, 307, 308].includes(statusCode) && headers.location) {
+        res.resume();
+        const redirectedUrl = new URL(headers.location, parsedUrl).toString();
+        resolve(request(redirectedUrl, { headers, redirectCount: redirectCount + 1 }));
+        return;
+      }
+
+      if (statusCode >= 400) {
+        const chunks = [];
+        res.on('data', chunk => chunks.push(chunk));
+        res.on('end', () => {
+          const body = Buffer.concat(chunks).toString('utf8').trim();
+          const detail = body ? `: ${body}` : '';
+          reject(new Error(`请求失败 (${statusCode}) ${url}${detail}`));
+        });
+        return;
+      }
+
+      resolve(res);
+      }
+    );
+
+    req.on('error', reject);
+  });
+}
+
+async function fetchText(url, options = {}) {
+  const res = await request(url, options);
+  const chunks = [];
+
+  for await (const chunk of res) {
+    chunks.push(chunk);
+  }
+
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+async function withBaseUrlCandidates(baseUrl, relativePath, operation) {
+  const candidates = buildBaseUrlCandidates(baseUrl);
+  let lastError;
+
+  for (const candidate of candidates) {
+    const url = `${candidate}${relativePath}`;
+
+    try {
+      const result = await operation(url);
+      return { result, baseUrl: candidate, url };
+    } catch (error) {
+      lastError = error;
+    }
+  }
+
+  throw lastError;
+}
+
+async function fetchJson(url, options = {}) {
+  const text = await fetchText(url, options);
+
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new Error(`接口返回了无效 JSON: ${url}\n${error.message}`);
+  }
+}
+
+async function downloadToFile(url, filePath, options = {}) {
+  const res = await request(url, options);
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await pipeline(res, createWriteStream(filePath));
+}
+
+async function md5File(filePath) {
+  const buffer = await fs.readFile(filePath);
+  return crypto.createHash('md5').update(buffer).digest('hex');
+}
+
+async function extractZip(zipPath, targetDir) {
+  await fs.mkdir(targetDir, { recursive: true });
+  await pipeline(createReadStream(zipPath), unzipper.Extract({ path: targetDir }));
+}
+
+async function findPackageRoot(extractDir) {
+  const rootMetadata = path.join(extractDir, 'aisoul.json');
+  if (await fileExists(rootMetadata)) {
+    return extractDir;
+  }
+
+  const entries = await fs.readdir(extractDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+
+    const candidate = path.join(extractDir, entry.name);
+    if (await fileExists(path.join(candidate, 'aisoul.json'))) {
+      return candidate;
+    }
+  }
+
+  throw new Error('解压后的安装包中未找到 aisoul.json');
+}
+
+async function copyPackageContent(sourceDir, targetDir) {
+  const entries = await fs.readdir(sourceDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (entry.name === 'AGENTS.md') {
+      continue;
+    }
+
+    const sourcePath = path.join(sourceDir, entry.name);
+    const targetPath = path.join(targetDir, entry.name);
 
+    if (entry.isDirectory()) {
+      await fs.mkdir(targetPath, { recursive: true });
+      await copyPackageContent(sourcePath, targetPath);
+      continue;
+    }
+
+    await fs.mkdir(path.dirname(targetPath), { recursive: true });
+    await fs.writeFile(targetPath, await fs.readFile(sourcePath));
+  }
+}
+
+async function appendAgentsFile(sourceDir, workspacePath) {
+  const sourceAgentsPath = path.join(sourceDir, 'AGENTS.md');
+  if (!(await fileExists(sourceAgentsPath))) {
+    return false;
+  }
+
+  const workspaceAgentsPath = path.join(workspacePath, 'AGENTS.md');
+  const [sourceContent, existingContent] = await Promise.all([
+    fs.readFile(sourceAgentsPath, 'utf8'),
+    fileExists(workspaceAgentsPath)
+      ? fs.readFile(workspaceAgentsPath, 'utf8')
+      : Promise.resolve(''),
+  ]);
+
+  await fs.writeFile(
+    workspaceAgentsPath,
+    buildMergedAgentsContent(existingContent, sourceContent),
+    'utf8'
+  );
+
+  return true;
+}
+
+async function runCommand(command, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: process.env,
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', chunk => {
+      stdout += chunk.toString();
+    });
+
+    child.stderr.on('data', chunk => {
+      stderr += chunk.toString();
+    });
+
+    child.on('error', reject);
+    child.on('close', code => {
+      if (code === 0) {
+        resolve({ stdout: stdout.trim(), stderr: stderr.trim() });
+        return;
+      }
+
+      reject(
+        new Error(
+          [
+            `命令执行失败: ${command} ${args.join(' ')}`,
+            stdout.trim(),
+            stderr.trim(),
+          ]
+            .filter(Boolean)
+            .join('\n')
+        )
+      );
+    });
+  });
+}
+
+export function summarizeErrorMessage(error) {
+  const lines = String(error?.message || error || '')
+    .split('\n')
+    .map(line => line.trim())
+    .filter(Boolean);
+
+  if (lines.length === 0) {
+    return '未知错误';
+  }
+
+  for (const line of lines) {
+    const match = line.match(/"Message"\s*:\s*"([^"]+)"/);
+    if (match?.[1]) {
+      return match[1];
+    }
+  }
+
+  const detailLine = lines.find(line => !line.startsWith('命令执行失败:'));
+  return detailLine || lines[0];
+}
+
+async function listAgents() {
+  const { stdout } = await runCommand('openclaw', ['agents', 'list', '--json']);
+
+  if (!stdout) {
+    return [];
+  }
+
+  try {
+    return JSON.parse(stdout);
+  } catch (error) {
+    throw new Error(`无法解析 openclaw agents list --json 输出\n${error.message}`);
+  }
+}
+
+export function buildExistingAgentDeleteMessage(agentName, workspacePath) {
+  return [
+    `检测到已存在同名 agent "${agentName}"，请先删除后再安装。`,
+    `workspace: ${workspacePath}`,
+    `请执行: openclaw agents delete ${agentName}`,
+  ].join('\n');
+}
+
+async function resolveVersion(baseUrl, slug, user) {
+  const headers = buildRequestHeaders(user);
+  const { result: payload, baseUrl: resolvedBaseUrl } = await withBaseUrlCandidates(
+    baseUrl,
+    `/soul/info?slug=${encodeURIComponent(slug)}`,
+    url => fetchJson(url, { headers })
+  );
+  const version = payload?.data?.version;
+
+  if (!version) {
+    throw new Error(`接口未返回 ${slug} 的版本信息`);
+  }
+
+  return { version, baseUrl: resolvedBaseUrl };
+}
+
+async function installSkills(skills, workspacePath) {
+  if (!Array.isArray(skills) || skills.length === 0) {
+    return {
+      installedSkills: [],
+      skippedSkills: [],
+    };
+  }
+
+  const installedSkills = [];
+  const skippedSkills = [];
+
+  for (const skill of skills) {
+    const skillName = normalizeSkillName(skill);
+    if (!skillName) {
+      continue;
+    }
+
+    try {
+      await runCommand('npx', [
+        'clawhub',
+        'install',
+        skillName,
+        '--workdir',
+        workspacePath,
+        '--registry',
+        CLAWHUB_REGISTRY,
+      ]);
+
+      installedSkills.push({
+        requested: String(skill),
+        installed: skillName,
+      });
+    } catch (error) {
+      const reason = summarizeErrorMessage(error);
+      skippedSkills.push({
+        requested: String(skill),
+        installed: skillName,
+        reason,
+      });
+      console.warn(`- 跳过 skill: ${skillName}${reason ? ` (${reason})` : ''}`);
+    }
+  }
+
+  return {
+    installedSkills,
+    skippedSkills,
+  };
+}
+
+function printSummary(summary) {
+  console.log('\n安装完成');
+  console.log(`- slug: ${summary.slug}`);
+  console.log(`- version: ${summary.version}`);
+  console.log(`- user: ${summary.user}`);
+  console.log(`- workspace: ${summary.workspacePath}`);
+  console.log(`- agent: ${summary.agentName}`);
+  console.log(`- display_name: ${summary.displayName}`);
+  console.log(`- base_url: ${summary.baseUrl}`);
+  console.log(`- agents_appended: ${summary.agentsAppended ? 'yes' : 'no'}`);
+  console.log(
+    `- skills: ${
+      summary.installedSkills.length > 0
+        ? summary.installedSkills.map(item => item.installed).join(', ')
+        : 'none'
+    }`
+  );
+  console.log(
+    `- skipped_skills: ${
+      summary.skippedSkills.length > 0
+        ? summary.skippedSkills
+            .map(item => `${item.installed}${item.reason ? ` (${item.reason})` : ''}`)
+            .join(', ')
+        : 'none'
+    }`
+  );
+}
+
+export async function installSoul({ soulSpecifier, user, baseUrl }) {
+  const { slug, version: rawVersion } = parseSoulSpecifier(soulSpecifier);
+  let effectiveBaseUrl = normalizeBaseUrl(baseUrl);
+  let version = rawVersion;
+  const defaultWorkspacePath = path.join(os.homedir(), '.openclaw', `workspace-${slug}`);
+  const agentName = slug;
+  const existingAgent = findExistingAgent(await listAgents(), agentName);
+
+  if (existingAgent) {
+    throw new UserFacingError(
+      buildExistingAgentDeleteMessage(
+        agentName,
+        existingAgent.workspace || defaultWorkspacePath
+      )
+    );
+  }
+
+  if (!version) {
+    const resolved = await resolveVersion(effectiveBaseUrl, slug, user);
+    version = resolved.version;
+    effectiveBaseUrl = resolved.baseUrl;
+  }
+
+  const packageName = `${slug}-${version}.zip`;
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aisoulhub-'));
+  const zipPath = path.join(tempRoot, packageName);
+  const extractDir = path.join(tempRoot, 'unzipped');
+  const workspacePath = defaultWorkspacePath;
+
+  try {
+    const requestHeaders = buildRequestHeaders(user);
+    const zipRelativePath = `/package/${packageName}`;
+    const md5RelativePath = `${zipRelativePath}.md5`;
+
+    console.log(`开始安装 ${slug}${rawVersion ? `@${version}` : `，解析到版本 ${version}`}`);
+
+    const { baseUrl: resolvedPackageBaseUrl, url: zipUrl } = await withBaseUrlCandidates(
+      effectiveBaseUrl,
+      zipRelativePath,
+      url => downloadToFile(url, zipPath, { headers: requestHeaders })
+    );
+    effectiveBaseUrl = resolvedPackageBaseUrl;
+    const md5Url = `${effectiveBaseUrl}${md5RelativePath}`;
+
+    console.log(`下载地址: ${zipUrl}`);
+
+    const remoteMd5 = extractMd5Hash(
+      await fetchText(md5Url, { headers: requestHeaders })
+    );
+    const localMd5 = await md5File(zipPath);
+
+    if (remoteMd5 !== localMd5) {
+      throw new Error(`MD5 校验失败，期望 ${remoteMd5}，实际 ${localMd5}`);
+    }
+
+    await extractZip(zipPath, extractDir);
+    const packageRoot = await findPackageRoot(extractDir);
+    const aisoulJsonPath = path.join(packageRoot, 'aisoul.json');
+    const metadata = JSON.parse(await fs.readFile(aisoulJsonPath, 'utf8'));
+    const displayName = String(metadata.nick_name || slug).trim() || slug;
+
+    await runCommand('openclaw', [
+      'agents',
+      'add',
+      agentName,
+      '--non-interactive',
+      '--workspace',
+      workspacePath,
+    ]);
+
+    await runCommand('openclaw', [
+      'agents',
+      'set-identity',
+      '--agent',
+      agentName,
+      '--name',
+      displayName,
+    ]);
+
+    await fs.mkdir(workspacePath, { recursive: true });
+    await copyPackageContent(packageRoot, workspacePath);
+    const agentsAppended = await appendAgentsFile(packageRoot, workspacePath);
+    const { installedSkills, skippedSkills } = await installSkills(
+      metadata.skills,
+      workspacePath
+    );
+
+    await runCommand('openclaw', [
+      'agent',
+      '--agent',
+      agentName,
+      '--message',
+      `Hi,你的名字是 ${displayName}`,
+    ]);
+
+    printSummary({
+      slug,
+      version,
+      user,
+      workspacePath,
+      agentName,
+      displayName,
+      baseUrl: effectiveBaseUrl,
+      agentsAppended,
+      installedSkills,
+      skippedSkills,
+    });
+  } finally {
+    await fs.rm(tempRoot, { recursive: true, force: true });
+  }
+}
+
+export async function main(argv = process.argv) {
   const program = new Command();
 
   program
     .name('aisoulhub')
-    .description('AISoulHub CLI tool for installing Agent skills and configurations')
-    .version(pkg.version);
+    .description('安装和更新 aisoul 到 OpenClaw workspace')
+    .showHelpAfterError();
 
   program
     .command('install')
-    .description('Install new Agent configuration and skills from a local zip file')
-    .argument('<path_to_zip>', 'Specify the local path to the zip file')
-    .action(async (aiSoulId) => {
-      await installCommand(aiSoulId);
+    .description('安装指定 aisoul 到本地 OpenClaw workspace')
+    .argument('<soul>', 'aisoul 标识，格式为 slug 或 slug@version')
+    .requiredOption('--user <email>', '用于标识当前安装用户')
+    .option('--base_url <url>', 'aisoulhub 服务地址', DEFAULT_BASE_URL)
+    .action(async (soul, options) => {
+      await installSoul({
+        soulSpecifier: soul,
+        user: options.user,
+        baseUrl: options.base_url,
+      });
+    });
+
+  program
+    .command('update')
+    .description('预留的更新命令')
+    .action(() => {
+      console.error('update 命令暂未实现');
+      process.exit(1);
     });
 
-  program.parseAsync(process.argv);
+  await program.parseAsync(argv);
 }

package/src/commands/install.js

@@ -1,164 +0,0 @@
-import { checkOpenclaw } from '../utils/check.js';
-import { getAgents, addAgent, setAgentIdentity } from '../utils/openclaw.js';
-import { extractLocalZip } from '../utils/download.js';
-import { processMetaJson } from '../utils/meta.js';
-import { select, input, confirm } from '@inquirer/prompts';
-import chalk from 'chalk';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import unzipper from 'unzipper';
-
-export async function installCommand(zipPath) {
-  if (!zipPath) {
-    console.error(chalk.red('❌ Error: zip path is required, e.g.: aisoulhub install <path_to_zip>'));
-    process.exit(1);
-  }
-
-  // 检查是否为本地 zip 文件
-  if (!zipPath.endsWith('.zip') || !fs.existsSync(path.resolve(zipPath))) {
-    console.error(chalk.red(`❌ Error: Invalid or missing local zip file at [${zipPath}]`));
-    process.exit(1);
-  }
-  const localZipPath = path.resolve(zipPath);
-
-  // 1. 前置检查
-  checkOpenclaw();
-
-  // 2. 获取当前的 agents 列表
-  let agents = [];
-  try {
-    agents = getAgents();
-  } catch (err) {
-    console.error(chalk.yellow(`⚠️ Failed to get agents list: ${err.message}`));
-  }
-
-  // 3. 提示用户选择或创建 Agent
-  const choices = [
-    { name: '✨ Create new Agent', value: { name: 'create_new', path: null } },
-    ...agents.map(a => ({ name: `📁 ${a.name} (${a.path})`, value: { name: a.name, path: a.path } }))
-  ];
-
-  const agentChoice = await select({
-    message: 'Please select the Agent to install:',
-    choices
-  });
-
-  if (agentChoice.name === 'main') {
-    const isConfirmed = await confirm({
-      message: chalk.yellow('⚠️ Warning: Overwriting the "main" agent might cause unexpected issues. Are you sure you want to continue?'),
-      default: false
-    });
-    
-    if (!isConfirmed) {
-      console.log(chalk.blue('ℹ️ Operation cancelled by user.'));
-      process.exit(0);
-    }
-  }
-
-  let targetPath = agentChoice.path;
-  let finalAgentName = agentChoice.name;
-
-  if (agentChoice.name === 'create_new') {
-    let defaultAgentName = '';
-    let identityName = '';
-    
-    // 尝试从 zip 文件中的 aisoul-meta.json 获取默认 name 和 slug
-    try {
-      const directory = await unzipper.Open.file(localZipPath);
-      const metaFile = directory.files.find(d => d.path === 'aisoul-meta.json');
-      if (metaFile) {
-        const content = await metaFile.buffer();
-        const meta = JSON.parse(content.toString('utf-8'));
-        if (meta.slug) {
-          defaultAgentName = meta.slug;
-        }
-        if (meta.name) {
-          identityName = meta.name;
-        }
-      }
-    } catch (err) {
-      // 忽略读取 zip 出错的情况
-    }
-
-    const newAgentName = await input({
-      message: 'Please enter the name of the new Agent:',
-      default: defaultAgentName,
-      validate: (val) => {
-        if (val.trim().length === 0) return 'Agent name cannot be empty';
-        if (val.trim().toLowerCase() === 'main') return '"main" is reserved. Choose another name.';
-        return true;
-      }
-    });
-    
-    finalAgentName = newAgentName;
-
-    const defaultWorkspace = path.join(os.homedir(), '.openclaw', `workspace-${newAgentName}`);
-    
-    const newWorkspacePath = await input({
-      message: 'Please enter the workspace directory for the new Agent:',
-      default: defaultWorkspace,
-      validate: (val) => val.trim().length > 0 ? true : 'Workspace directory cannot be empty'
-    });
-    
-    console.log(chalk.cyan(`🔄 Creating Agent [${newAgentName}]...`));
-    try {
-      addAgent(newAgentName, newWorkspacePath);
-      console.log(chalk.green(`✅ Agent [${newAgentName}] created successfully.`));
-      
-      // 设置 Agent 的显示名称
-      if (identityName) {
-        try {
-          setAgentIdentity(newAgentName, identityName);
-          console.log(chalk.green(`✅ Agent identity name set to [${identityName}].`));
-        } catch (identityErr) {
-          console.error(chalk.yellow(`⚠️ Warning: Failed to set identity name: ${identityErr.message}`));
-        }
-      }
-      
-      // 重新获取列表以获取新 agent 的路径
-      const updatedAgents = getAgents();
-      const newAgent = updatedAgents.find(a => a.name === newAgentName);
-      if (!newAgent || !newAgent.path) {
-        targetPath = newWorkspacePath;
-      } else {
-        targetPath = newAgent.path;
-      }
-    } catch (err) {
-      console.error(chalk.red(err.message));
-      process.exit(1);
-    }
-  }
-
-  if (!targetPath) {
-    console.error(chalk.red('❌ Error: Unable to determine the workspace directory path for the Agent.'));
-    process.exit(1);
-  }
-
-  console.log(chalk.blue(`ℹ️ Target workspace directory: ${targetPath}`));
-
-  // 4. 解压本地 ZIP 文件
-  const extractSuccess = await extractLocalZip(localZipPath, targetPath);
-
-  if (!extractSuccess) {
-    process.exit(1);
-  }
-
-  // 5. 解析 aisoul-meta.json 并安装技能
-  await processMetaJson(targetPath);
-
-  console.log(chalk.green(`🎉 Successfully installed local package to the Agent.`));
-  
-  // 直接唤醒 Agent
-  console.log(chalk.cyan(`\n👉 Waking up the agent...`));
-  const { spawn } = await import('child_process');
-  
-  const child = spawn('openclaw', ['agent', '--agent', finalAgentName, '--message', 'hi'], {
-    stdio: 'inherit',
-    shell: true
-  });
-
-  child.on('error', (error) => {
-    console.error(chalk.red(`❌ Failed to start the agent: ${error.message}`));
-  });
-}

package/src/utils/check.js

@@ -1,9 +0,0 @@
-import shell from 'shelljs';
-import chalk from 'chalk';
-
-export function checkOpenclaw() {
-  if (!shell.which('openclaw')) {
-    console.error(chalk.red('❌ Error: openclaw command not found. Please follow the instructions at https://openclaw.ai to install openclaw, then try again.'));
-    process.exit(1);
-  }
-}

package/src/utils/download.js

@@ -1,26 +0,0 @@
-import fs from 'fs';
-import unzipper from 'unzipper';
-import ora from 'ora';
-import chalk from 'chalk';
-
-export async function extractLocalZip(zipPath, targetPath) {
-  const spinner = ora(`Extracting local package from ${zipPath}...`).start();
-
-  try {
-    // Ensure target path exists
-    if (!fs.existsSync(targetPath)) {
-      fs.mkdirSync(targetPath, { recursive: true });
-    }
-
-    // Unzip
-    await fs.createReadStream(zipPath)
-      .pipe(unzipper.Extract({ path: targetPath }))
-      .promise();
-
-    spinner.succeed(chalk.green(`Local package extracted successfully.`));
-    return true;
-  } catch (err) {
-    spinner.fail(chalk.red(`Error: Failed to extract the local package: ${err.message}`));
-    return false;
-  }
-}

package/src/utils/meta.js

@@ -1,25 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import chalk from 'chalk';
-import { installSkill } from './openclaw.js';
-
-export async function processMetaJson(workspacePath) {
-  const metaPath = path.join(workspacePath, 'aisoul-meta.json');
-  if (!fs.existsSync(metaPath)) {
-    console.log(chalk.yellow(`ℹ️ aisoul-meta.json not found, skipping skill installation. (${metaPath})`));
-    return;
-  }
-
-  try {
-    const content = fs.readFileSync(metaPath, 'utf-8');
-    const meta = JSON.parse(content);
-    const skills = meta.skills || [];
-    
-    if (skills.length === 0) {
-      console.log(chalk.blue('ℹ️ No skills defined to install in aisoul-meta.json.'));
-      return;
-    }
-  } catch (err) {
-    console.error(chalk.red(`❌ Failed to read or parse aisoul-meta.json: ${err.message}`));
-  }
-}

package/src/utils/openclaw.js

@@ -1,97 +0,0 @@
-import shell from 'shelljs';
-
-export function getAgents() {
-  const result = shell.exec('openclaw agents list --json', { silent: true });
-  if (result.code !== 0) {
-    throw new Error('Failed to get agents list: ' + result.stderr);
-  }
-  
-  // Try to parse JSON first
-  try {
-    // 尝试提取标准 JSON 数组结构（截取第一个 '[' 到匹配的 ']' 的内容）
-    // 为了防止截取到后面的无关内容，我们查找从 '[' 开始，以 ']' 结束，并且紧跟换行或结尾的部分
-    const jsonMatch = result.stdout.match(/\[[\s\S]*?\n\]/);
-    if (jsonMatch) {
-      const list = JSON.parse(jsonMatch[0]);
-      if (Array.isArray(list)) {
-        return list.map(item => ({
-          name: item.id || item.name,
-          path: item.workspace || item.path || item.agentDir
-        }));
-      }
-    } else {
-      // 如果没有匹配到数组结构，则尝试直接解析
-      const list = JSON.parse(result.stdout);
-      if (Array.isArray(list)) {
-        return list.map(item => ({
-          name: item.id || item.name,
-          path: item.workspace || item.path || item.agentDir
-        }));
-      }
-    }
-  } catch (err) {
-    // Not JSON, parse text
-  }
-
-  // Fallback text parsing
-  const lines = result.stdout.split('\n');
-  const agents = [];
-  
-  // Regex to match agent name and path. E.g., "- agent1 (/path/to/agent1)" or "agent1: /path/to/agent1"
-  // Let's just do a generic parsing or return raw lines if we can't be sure.
-  for (const line of lines) {
-    const match = line.match(/(?:-\s+)?(\w+)(?:\s+\((.*?)\)|:\s+(.*))?/);
-    if (match && match[1] && match[1] !== 'Agents') {
-      const name = match[1].trim();
-      const pathStr = (match[2] || match[3] || '').trim();
-      if (name) {
-        agents.push({ name, path: pathStr || null });
-      }
-    }
-  }
-  return agents;
-}
-
-export function addAgent(name, workspacePath) {
-  let cmd = `openclaw agents add "${name}"`;
-  if (workspacePath) {
-    cmd += ` --non-interactive --workspace "${workspacePath}"`;
-  }
-  const result = shell.exec(cmd, { silent: true });
-  if (result.code !== 0) {
-    throw new Error(`Failed to create agent [${name}]: ` + result.stderr);
-  }
-  return result.stdout;
-}
-
-export function setAgentIdentity(agentName, identityName) {
-  const cmd = `openclaw agents set-identity --agent "${agentName}" --name "${identityName}"`;
-  const result = shell.exec(cmd, { silent: true });
-  if (result.code !== 0) {
-    throw new Error(`Failed to set agent identity for [${agentName}]: ` + result.stderr);
-  }
-  return result.stdout;
-}
-
-export async function installSkill(workspacePath, skillStr, retryCount = 0) {
-  const maxRetries = 3;
-  const result = shell.exec(`npx clawhub install ${skillStr} --workdir "${workspacePath}"`, { silent: true });
-  
-  if (result.code !== 0) {
-    const errorOutput = result.stderr || result.stdout;
-    if (errorOutput.includes('Rate limit exceeded')) {
-      if (retryCount < maxRetries) {
-        console.log(`⚠️ Rate limit exceeded. Waiting 5 seconds before retrying (${retryCount + 1}/${maxRetries})...`);
-        await new Promise(resolve => setTimeout(resolve, 5000));
-        return installSkill(workspacePath, skillStr, retryCount + 1);
-      } else {
-        console.error(`❌ Failed to install skill ${skillStr} after ${maxRetries} retries due to rate limit.`);
-        return false;
-      }
-    }
-    
-    console.error(`❌ Failed to install skill ${skillStr}: `, errorOutput);
-    return false;
-  }
-  return true;
-}