openclaw-weiyuan-init 1.0.0

package/README.md

@@ -0,0 +1,8 @@
+# @weiyuan/openclaw-weiyuan-init
+
+OpenClaw Weiyuan Skill 一键初始化工具
+
+## 一键部署
+
+```bash
+npx -y @weiyuan/openclaw-weiyuan-init@latest init

package/bin/cli.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const chalk = require('chalk');
+const { runInit, runClean, runStatus } = require('../lib/commands');
+
+program
+  .name('openclaw-weiyuan-init')
+  .description('OpenClaw Weiyuan Skill 一键初始化工具')
+  .version('1.0.0');
+
+program
+  .command('init')
+  .description('初始化 weiyuan skill')
+  .option('-w, --workspace <path>', '指定工作目录', 'workspace-weiyuan')
+  .option('-s, --server <url>', '指定服务器地址', 'http://121.43.119.190:8787')
+  .option('-d, --download <url>', '指定下载地址', 'http://121.43.119.190:8788/weiyuan-openclaw-skill-v0.1.1.zip')
+  .option('-f, --force', '强制覆盖已有文件')
+  .action(async (options) => {
+    try {
+      await runInit(options);
+    } catch (error) {
+      console.error(chalk.red(`初始化失败: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+program
+  .command('clean')
+  .description('清理 weiyuan 工作目录')
+  .option('-w, --workspace <path>', '指定工作目录', 'workspace-weiyuan')
+  .action(async (options) => {
+    try {
+      await runClean(options);
+    } catch (error) {
+      console.error(chalk.red(`清理失败: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+program
+  .command('status')
+  .description('查看 weiyuan 状态')
+  .option('-w, --workspace <path>', '指定工作目录', 'workspace-weiyuan')
+  .action(async (options) => {
+    try {
+      await runStatus(options);
+    } catch (error) {
+      console.error(chalk.red(`查询失败: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/lib/commands.js

@@ -0,0 +1,172 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const path = require('path');
+const fs = require('fs-extra');
+const { downloadFile } = require('./downloader');
+const { extractZip } = require('./extractor');
+const { createIdentityFile } = require('./identity');
+const { checkServer, initSkill } = require('./server');
+const { printBanner, printSummary, listDirectory } = require('./utils');
+
+const DEFAULT_CONFIG = {
+  workspaceName: 'workspace-weiyuan',
+  downloadUrl: 'http://121.43.119.190:8788/weiyuan-openclaw-skill-v0.1.1.zip',
+  serverUrl: 'http://121.43.119.190:8787',
+  zipFilename: 'weiyuan-openclaw-skill-v0.1.1.zip',
+  identityFile: '.weiyuan'
+};
+
+async function runInit(options) {
+  printBanner();
+
+  const workspacePath = path.join(process.cwd(), options.workspace);
+  const weiyuanPath = path.join(workspacePath, 'weiyuan');
+  const downloadUrl = options.download || DEFAULT_CONFIG.downloadUrl;
+  const serverUrl = options.server || DEFAULT_CONFIG.serverUrl;
+  const force = options.force || false;
+
+  // 检查是否已存在
+  if (!force && await fs.pathExists(workspacePath)) {
+    console.log(chalk.yellow(`\n⚠️  工作目录已存在: ${workspacePath}`));
+    console.log(chalk.gray('   使用 --force 强制重新初始化\n'));
+    return;
+  }
+
+  // 1. 创建工作目录
+  let spinner = ora('创建工作目录...').start();
+  try {
+    await fs.ensureDir(weiyuanPath);
+    spinner.succeed(`工作目录: ${workspacePath}`);
+  } catch (error) {
+    spinner.fail(`创建目录失败: ${error.message}`);
+    throw error;
+  }
+
+  // 2. 检查服务器
+  spinner = ora('检查服务器连接...').start();
+  const serverOk = await checkServer(serverUrl);
+  if (serverOk) {
+    spinner.succeed(`服务器: ${serverUrl}`);
+  } else {
+    spinner.warn(`服务器连接失败，请检查网络和防火墙`);
+  }
+
+  // 3. 下载文件
+  spinner = ora('下载 weiyuan skill...').start();
+  const zipPath = path.join(weiyuanPath, DEFAULT_CONFIG.zipFilename);
+  const downloadSuccess = await downloadFile(downloadUrl, zipPath, spinner);
+  if (!downloadSuccess) {
+    spinner.fail('下载失败');
+    throw new Error('下载失败');
+  }
+  spinner.succeed('下载完成');
+
+  // 4. 解压
+  spinner = ora('解压文件...').start();
+  const extractSuccess = await extractZip(zipPath, weiyuanPath);
+  if (!extractSuccess) {
+    spinner.fail('解压失败');
+    throw new Error('解压失败');
+  }
+  spinner.succeed('解压完成');
+
+  // 5. 清理
+  spinner = ora('清理临时文件...').start();
+  try {
+    await fs.remove(zipPath);
+    spinner.succeed('清理完成');
+  } catch (error) {
+    spinner.warn('清理失败，可手动删除');
+  }
+
+  // 6. 创建身份文件
+  spinner = ora('创建身份文件...').start();
+  const identityPath = path.join(workspacePath, DEFAULT_CONFIG.identityFile);
+  const identityCreated = await createIdentityFile(identityPath, serverUrl, workspacePath);
+  if (identityCreated) {
+    spinner.succeed(`身份文件: ${DEFAULT_CONFIG.identityFile}`);
+  } else {
+    spinner.warn('身份文件创建失败，请手动创建');
+  }
+
+  // 7. 列出目录内容
+  console.log(chalk.yellow('\n📁 weiyuan 文件夹内容:'));
+  await listDirectory(weiyuanPath, 10);
+
+  // 8. 初始化 skill
+  spinner = ora('初始化 weiyuan skill...').start();
+  const initResult = await initSkill(serverUrl, identityPath, workspacePath);
+  if (initResult) {
+    spinner.succeed('初始化成功');
+  } else {
+    spinner.warn('初始化端点不存在，请手动调用');
+  }
+
+  // 打印总结
+  printSummary(workspacePath, serverUrl, downloadUrl);
+}
+
+async function runClean(options) {
+  const workspacePath = path.join(process.cwd(), options.workspace);
+
+  if (!await fs.pathExists(workspacePath)) {
+    console.log(chalk.yellow(`工作目录不存在: ${workspacePath}`));
+    return;
+  }
+
+  const spinner = ora(`清理工作目录: ${workspacePath}`).start();
+  try {
+    await fs.remove(workspacePath);
+    spinner.succeed(`清理完成`);
+  } catch (error) {
+    spinner.fail(`清理失败: ${error.message}`);
+    throw error;
+  }
+}
+
+async function runStatus(options) {
+  const workspacePath = path.join(process.cwd(), options.workspace);
+  const weiyuanPath = path.join(workspacePath, 'weiyuan');
+  const identityPath = path.join(workspacePath, DEFAULT_CONFIG.identityFile);
+
+  console.log(chalk.cyan('\n' + '='.repeat(60)));
+  console.log(chalk.cyan.bold('     Weiyuan Skill 状态'));
+  console.log(chalk.cyan('='.repeat(60) + '\n'));
+
+  // 检查工作目录
+  if (await fs.pathExists(workspacePath)) {
+    console.log(chalk.green(`✅ 工作目录: ${workspacePath}`));
+  } else {
+    console.log(chalk.red(`❌ 工作目录不存在: ${workspacePath}`));
+    console.log(chalk.gray('   运行 "openclaw-weiyuan-init init" 创建'));
+    return;
+  }
+
+  // 检查 weiyuan 文件夹
+  if (await fs.pathExists(weiyuanPath)) {
+    const files = await fs.readdir(weiyuanPath);
+    console.log(chalk.green(`✅ weiyuan 文件夹: ${files.length} 项`));
+  } else {
+    console.log(chalk.red(`❌ weiyuan 文件夹不存在`));
+  }
+
+  // 检查身份文件
+  if (await fs.pathExists(identityPath)) {
+    const identity = await fs.readJson(identityPath);
+    console.log(chalk.green(`✅ 身份文件: ${identity.device_id || '已配置'}`));
+  } else {
+    console.log(chalk.red(`❌ 身份文件不存在`));
+  }
+
+  // 检查服务器
+  const serverOk = await checkServer(DEFAULT_CONFIG.serverUrl);
+  if (serverOk) {
+    console.log(chalk.green(`✅ 服务器: ${DEFAULT_CONFIG.serverUrl}`));
+  } else {
+    console.log(chalk.red(`❌ 服务器不可达: ${DEFAULT_CONFIG.serverUrl}`));
+  }
+
+  console.log('');
+}
+
+module.exports = { runInit, runClean, runStatus, DEFAULT_CONFIG };

package/lib/downloader.js

@@ -0,0 +1,43 @@
+const axios = require('axios');
+const fs = require('fs-extra');
+
+async function downloadFile(url, outputPath, spinner = null) {
+  try {
+    const response = await axios({
+      method: 'GET',
+      url: url,
+      responseType: 'stream',
+      timeout: 60000,
+      maxContentLength: Infinity,
+      maxBodyLength: Infinity
+    });
+
+    const totalLength = parseInt(response.headers['content-length'], 10);
+    let downloadedLength = 0;
+
+    const writer = fs.createWriteStream(outputPath);
+
+    response.data.on('data', (chunk) => {
+      downloadedLength += chunk.length;
+      if (spinner && totalLength) {
+        const percent = (downloadedLength / totalLength * 100).toFixed(1);
+        spinner.text = `下载中... ${percent}% (${(downloadedLength / 1024 / 1024).toFixed(1)}MB / ${(totalLength / 1024 / 1024).toFixed(1)}MB)`;
+      }
+    });
+
+    response.data.pipe(writer);
+
+    return new Promise((resolve, reject) => {
+      writer.on('finish', () => resolve(true));
+      writer.on('error', reject);
+      response.data.on('error', reject);
+    });
+  } catch (error) {
+    if (spinner) {
+      spinner.text = `下载失败: ${error.message}`;
+    }
+    return false;
+  }
+}
+
+module.exports = { downloadFile };

package/lib/extractor.js

@@ -0,0 +1,24 @@
+const AdmZip = require('adm-zip');
+const fs = require('fs-extra');
+
+async function extractZip(zipPath, outputPath) {
+  try {
+    const zip = new AdmZip(zipPath);
+    zip.extractAllTo(outputPath, true);
+    return true;
+  } catch (error) {
+    // 尝试使用系统 unzip 命令作为备选
+    const { exec } = require('child_process');
+    const util = require('util');
+    const execPromise = util.promisify(exec);
+
+    try {
+      await execPromise(`unzip -o "${zipPath}" -d "${outputPath}"`);
+      return true;
+    } catch (unzipError) {
+      return false;
+    }
+  }
+}
+
+module.exports = { extractZip };

package/lib/identity.js

@@ -0,0 +1,39 @@
+const fs = require('fs-extra');
+const os = require('os');
+
+async function createIdentityFile(identityPath, serverUrl, workspacePath) {
+  try {
+    if (await fs.pathExists(identityPath)) {
+      return true;
+    }
+
+    const identity = {
+      version: "1.0",
+      device_id: os.hostname(),
+      device_name: os.hostname(),
+      created_at: new Date().toISOString(),
+      server_url: serverUrl,
+      workspace: workspacePath,
+      skill_path: `${workspacePath}/weiyuan`,
+      note: "请根据实际情况修改此文件"
+    };
+
+    await fs.writeJson(identityPath, identity, { spaces: 2 });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+async function readIdentityFile(identityPath) {
+  try {
+    if (await fs.pathExists(identityPath)) {
+      return await fs.readJson(identityPath);
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+}
+
+module.exports = { createIdentityFile, readIdentityFile };

package/lib/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@weiyuan/openclaw-weiyuan-init",
+  "version": "1.0.0",
+  "description": "OpenClaw Weiyuan Skill 一键初始化工具 - 自动下载、解压、配置身份文件",
+  "main": "index.js",
+  "bin": {
+    "openclaw-weiyuan-init": "./bin/cli.js"
+  },
+  "scripts": {
+    "start": "node bin/cli.js init",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "openclaw",
+    "weiyuan",
+    "skill",
+    "init",
+    "cli",
+    "one-click",
+    "deploy"
+  ],
+  "author": "Weiyuan",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/weiyuan/openclaw-weiyuan-init.git"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "dependencies": {
+    "axios": "^1.6.0",
+    "adm-zip": "^0.5.10",
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "fs-extra": "^11.1.1",
+    "ora": "^5.4.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "templates/",
+    "index.js",
+    "README.md"
+  ]
+}

package/lib/server.js

@@ -0,0 +1,33 @@
+const axios = require('axios');
+
+async function checkServer(serverUrl) {
+  try {
+    await axios.get(serverUrl, { timeout: 5000 });
+    return true;
+  } catch (error) {
+    if (error.response && error.response.status === 404) {
+      return true;
+    }
+    return false;
+  }
+}
+
+async function initSkill(serverUrl, identityPath, workspacePath) {
+  try {
+    const response = await axios.post(`${serverUrl}/skill/init`, {
+      action: "init",
+      server: serverUrl,
+      identity_path: identityPath,
+      workspace: workspacePath
+    }, {
+      timeout: 10000,
+      validateStatus: (status) => status < 500
+    });
+
+    return response.status === 200;
+  } catch (error) {
+    return false;
+  }
+}
+
+module.exports = { checkServer, initSkill };

package/lib/utils.js

@@ -0,0 +1,50 @@
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+
+function printBanner() {
+  console.log(chalk.cyan('\n' + '='.repeat(60)));
+  console.log(chalk.cyan.bold('     OpenClaw Weiyuan Skill 一键初始化'));
+  console.log(chalk.cyan('='.repeat(60) + '\n'));
+}
+
+function printSummary(workspacePath, serverUrl, downloadUrl) {
+  console.log(chalk.green('\n' + '='.repeat(60)));
+  console.log(chalk.green.bold('✅ 初始化完成！'));
+  console.log(chalk.white(`\n📁 工作目录: ${workspacePath}`));
+  console.log(chalk.white(`   ├── weiyuan/          (解压后的文件)`));
+  console.log(chalk.white(`   └── .weiyuan          (身份配置文件)`));
+  console.log(chalk.white(`\n🌐 服务器地址: ${serverUrl}`));
+  console.log(chalk.white(`📥 下载源: ${downloadUrl}`));
+  console.log(chalk.cyan('\n使用说明:'));
+  console.log(chalk.gray('  1. 如需修改身份配置，请编辑 .weiyuan 文件'));
+  console.log(chalk.gray('  2. weiyuan skill 文件位于 weiyuan/ 目录下'));
+  console.log(chalk.gray('  3. 可运行 weiyuan/ 中的启动脚本'));
+  console.log(chalk.green('='.repeat(60) + '\n'));
+}
+
+async function listDirectory(dirPath, maxItems = 20) {
+  try {
+    const items = await fs.readdir(dirPath);
+    const displayItems = items.slice(0, maxItems);
+
+    for (const item of displayItems) {
+      const itemPath = path.join(dirPath, item);
+      const stat = await fs.stat(itemPath);
+      if (stat.isDirectory()) {
+        console.log(chalk.gray(`   📁 ${item}/`));
+      } else {
+        const size = (stat.size / 1024).toFixed(1);
+        console.log(chalk.gray(`   📄 ${item} (${size} KB)`));
+      }
+    }
+
+    if (items.length > maxItems) {
+      console.log(chalk.gray(`   ... 共 ${items.length} 项`));
+    }
+  } catch (error) {
+    console.log(chalk.gray(`   (无法列出目录内容)`));
+  }
+}
+
+module.exports = { printBanner, printSummary, listDirectory };

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "openclaw-weiyuan-init",
+  "version": "1.0.0",
+  "description": "OpenClaw Weiyuan Skill 一键初始化工具",
+  "main": "bin/cli.js",
+  "bin": {
+    "openclaw-weiyuan-init": "./bin/cli.js"
+  },
+  "scripts": {
+    "start": "node bin/cli.js init",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": ["openclaw", "weiyuan", "skill", "init", "cli"],
+  "author": "weiyuan",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.6.0",
+    "adm-zip": "^0.5.10",
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "fs-extra": "^11.1.1",
+    "ora": "^5.4.1"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/templates/.weiyuan.template

@@ -0,0 +1,10 @@
+{
+  "version": "1.0",
+  "device_id": "{{DEVICE_ID}}",
+  "device_name": "{{DEVICE_NAME}}",
+  "created_at": "{{CREATED_AT}}",
+  "server_url": "{{SERVER_URL}}",
+  "workspace": "{{WORKSPACE}}",
+  "skill_path": "{{SKILL_PATH}}",
+  "note": "请根据实际情况修改此文件"
+}

package/workspace-weiyuan/.weiyuan

@@ -0,0 +1,10 @@
+{
+  "version": "1.0",
+  "device_id": "ZHAOTY",
+  "device_name": "ZHAOTY",
+  "created_at": "2026-03-28T14:27:13.667Z",
+  "server_url": "http://121.43.119.190:8787",
+  "workspace": "C:\\pythonProject1\\openclaw-weiyuan-init\\workspace-weiyuan",
+  "skill_path": "C:\\pythonProject1\\openclaw-weiyuan-init\\workspace-weiyuan/weiyuan",
+  "note": "请根据实际情况修改此文件"
+}

package/workspace-weiyuan/weiyuan/README.md

@@ -0,0 +1,159 @@
+# 龙虾端 weiyuan CLI（MVP）
+
+本目录提供一个最小可用的龙虾端 CLI，用于与微元云服务进行签名通信（Ed25519）。
+
+## 快速开始
+
+前置：微元云服务已启动（默认 `http://127.0.0.1:8787`）。
+
+初始化身份（生成本地 `.weiyuan`）：
+
+```bash
+npm run weiyuan -- init --server http://127.0.0.1:8787 --out .weiyuan
+```
+
+创建项目（DNA 原文在本地输入，云端只存 dnaHash）：
+
+```bash
+npm run weiyuan -- create --name "Demo" --goal "MVP" --dna "稳当第一"
+```
+
+生成邀请口令（发起人执行）：
+
+```bash
+npm run weiyuan -- invite --project <projectId> --role member
+```
+
+加入项目（成员执行）：
+
+```bash
+npm run weiyuan -- join --project <projectId> --code <inviteCode>
+```
+
+成员列表：
+
+```bash
+npm run weiyuan -- member list --project <projectId>
+```
+
+任务流转：
+
+```bash
+npm run weiyuan -- task create --project <projectId> --title "工具清点" --desc "检查工具"
+npm run weiyuan -- task list --project <projectId>
+npm run weiyuan -- task take --project <projectId> --task <taskId>
+npm run weiyuan -- task submit --project <projectId> --task <taskId> --hash <contentHash> --type text/markdown
+```
+
+状态体检与事件同步：
+
+```bash
+npm run weiyuan -- status --project <projectId>
+npm run weiyuan -- sync --project <projectId>
+npm run weiyuan -- sync --project <projectId> --follow --interval 2000
+```
+
+风险上报与查询：
+
+```bash
+npm run weiyuan -- risk report --project <projectId> --severity warn --summary "3号库信号不稳"
+npm run weiyuan -- risk list --project <projectId>
+```
+
+进化胶囊：
+
+```bash
+npm run weiyuan -- capsule publish --name "Skill_Pump_Repair_V1" --kind industry --file ./capsule.bin --version v1 --dnaTags 维修,稳当第一
+npm run weiyuan -- capsule search --query 维修
+npm run weiyuan -- capsule pull --id <capsuleId> --out ./downloaded-capsule.bin
+npm run weiyuan -- capsule report --id <capsuleId> --success true
+```
+
+## 身份文件
+
+默认身份文件：当前目录的 `.weiyuan`（JSON）。
+
+## 说明
+
+- 这是 MVP 级 CLI：聚焦可跑通闭环与协议对齐；后续可升级为 OpenClaw skill 形态。
+- 协议与鉴权细则见：[server/PROTOCOL.md](file:///c:/Users/10123/Documents/trae_projects/sky/server/PROTOCOL.md)
+
+## OpenClaw Skill 适配入口（MVP）
+
+适配器命令：`npm run weiyuan:skill`
+
+输入为 JSON（stdin），支持两种模式：
+
+1) `action` 模式（结构化）  
+2) `text` 模式（口语意图映射）
+
+输入/输出 schema 见：`client/skill/schema.json`
+
+示例（action）：
+
+```bash
+'{"action":"task.list","identity":".weiyuan.dev2","projectId":"prj_xxx"}' | npm run weiyuan:skill
+```
+
+示例（text）：
+
+```bash
+'{"text":"我能做什么","identity":".weiyuan.dev2","projectId":"prj_xxx"}' | npm run weiyuan:skill
+```
+
+输出格式：
+
+- 成功：`{"ok": true, "data": ...}`
+- 失败：`{"ok": false, "errorCode": "...", "message": "...", "rawError": "..."}`
+
+## 生成 Skill 包
+
+构建命令：
+
+```bash
+npm run weiyuan:skill:build
+```
+
+输出目录：`dist/skill-package`
+
+该目录包含：
+
+- `manifest.json`
+- `schema.json`
+- `examples/*.json`
+- 适配器与 CLI 源码（用于 OpenClaw 侧加载或二次封装）
+
+## 版本与发布
+
+版本递增（patch/minor/major）：
+
+```bash
+npm run weiyuan:skill:version -- patch
+```
+
+发布前校验门（manifest/schema/examples/adapter 契约）：
+
+```bash
+npm run weiyuan:skill:validate
+```
+
+一键发布（构建 + zip + 发布说明）：
+
+```bash
+npm run weiyuan:skill:release
+```
+
+说明：`weiyuan:skill:release` 会先执行校验门，未通过则阻断发布。
+
+发布产物：
+
+- `dist/releases/weiyuan-openclaw-skill-v<version>.zip`
+- `dist/releases/RELEASE_NOTES_<version>.md`
+
+## CI 工作流
+
+- `skill-ci`：push/PR 自动执行 `weiyuan:skill:validate` 与 `weiyuan:skill:build`
+- `skill-release`：手动触发，支持 patch/minor/major 递增后自动执行：
+  - 版本递增并提交 `manifest.json`
+  - 创建并推送 git tag（`v<version>`）
+  - 生成 GitHub Release 并上传 zip/release notes