openclaw-weiyuan-init 1.0.5 → 1.0.13

package/README.md

@@ -5,7 +5,7 @@ OpenClaw Weiyuan Skill 一键初始化工具
 ## 一键部署
 
 ```bash
-npx -y @weiyuan/openclaw-weiyuan-init@latest init
+npx -y openclaw-weiyuan-init@latest init
 ```
 
 ## 版本化 zip 自动识别
@@ -17,19 +17,22 @@ npx -y @weiyuan/openclaw-weiyuan-init@latest init
 ## 常用参数
 
 ```bash
-npx -y @weiyuan/openclaw-weiyuan-init@latest init --upgrade <upgradeBaseUrl> --server <serverUrl>
+npx -y openclaw-weiyuan-init@latest init --upgrade <upgradeBaseUrl> --server <serverUrl>
 ```
 
+工作目录会自动归一化到 `<指定目录>/workspace-weiyuan`，身份文件固定写在该目录下的 `.weiyuan`。
+
 邀请码一键入组（推荐）：
 
 ```bash
-npx -y @weiyuan/openclaw-weiyuan-init@latest init --invite <inviteToken>
+npx -y openclaw-weiyuan-init@latest init --invite <inviteToken>
 ```
 
 `inviteToken` 包含 `server/upgrade/project/code`，会自动完成安装与入组。
+初始化过程会自动准备 `weiyuan` CLI 运行时依赖并生成完整 `.weiyuan` 身份文件。
 
 如需指定固定 zip，可覆盖自动识别：
 
 ```bash
-npx -y @weiyuan/openclaw-weiyuan-init@latest init --download <zipUrl> --server <serverUrl>
+npx -y openclaw-weiyuan-init@latest init --download <zipUrl> --server <serverUrl>
 ```

package/bin/cli.js

@@ -14,11 +14,11 @@ program
   .description('初始化 weiyuan skill')
   .option('-w, --workspace <path>', '指定工作目录', 'workspace-weiyuan')
   .option('-s, --server <url>', '指定服务器地址', 'http://121.43.119.190:8787')
-  .option('-u, --upgrade <url>', '指定升级源地址（含 LATEST_SKILL_VERSION.txt）', 'http://121.43.119.190:8788')
-  .option('-d, --download <url>', '指定下载地址（可覆盖自动版本解析）')
-  .option('-i, --invite <token>', '邀请码令牌（包含 server/upgrade/project/code）')
-  .option('-p, --project <id>', '邀请加入的项目 ID')
-  .option('-c, --code <code>', '邀请口令')
+  .option('-u, --upgrade <url>', '指定升级源地址（含 LATEST_SKILL_VERSION.txt）', 'http://121.43.119.190/upgrade')
+  .option('-d, --download <url>', '指定下载地址（可覆盖自动版本解析）')
+  .option('-i, --invite <token>', '邀请码令牌（包含 server/upgrade/project/code）')
+  .option('-p, --project <id>', '邀请加入的项目 ID')
+  .option('-c, --code <code>', '邀请口令')
   .option('-f, --force', '强制覆盖已有文件')
   .action(async (options) => {
     try {
@@ -46,7 +46,7 @@ program
   .command('status')
   .description('查看 weiyuan 状态')
   .option('-w, --workspace <path>', '指定工作目录', 'workspace-weiyuan')
-  .option('-s, --server <url>', '指定服务器地址', 'http://121.43.119.190:8787')
+  .option('-s, --server <url>', '指定服务器地址', 'http://121.43.119.190:8787')
   .action(async (options) => {
     try {
       await runStatus(options);
@@ -56,4 +56,4 @@ program
     }
   });
 
-program.parse();
+program.parse();

package/lib/commands.js

@@ -2,59 +2,133 @@ const chalk = require('chalk');
 const ora = require('ora');
 const path = require('path');
 const fs = require('fs-extra');
-const { execFile } = require('child_process');
-const { promisify } = require('util');
-const { downloadFile, resolvePackageSource } = require('./downloader');
+const { execFile } = require('child_process');
+const { promisify } = require('util');
+const { downloadFile, resolvePackageSource } = require('./downloader');
 const { extractZip } = require('./extractor');
 const { createIdentityFile } = require('./identity');
 const { checkServer, initSkill } = require('./server');
 const { printBanner, printSummary, listDirectory } = require('./utils');
-const execFileAsync = promisify(execFile);
+const execFileAsync = promisify(execFile);
 
 const DEFAULT_CONFIG = {
   workspaceName: 'workspace-weiyuan',
-  upgradeBaseUrl: 'http://121.43.119.190:8788',
-  downloadUrl: '',
+  upgradeBaseUrl: 'http://121.43.119.190/upgrade',
+  downloadUrl: '',
   serverUrl: 'http://121.43.119.190:8787',
   identityFile: '.weiyuan'
 };
-
-function decodeInviteToken(token) {
-  if (!token || typeof token !== 'string') return null;
-  try {
-    const normalized = token.replace(/-/g, '+').replace(/_/g, '/');
-    const pad = normalized.length % 4 === 0 ? '' : '='.repeat(4 - (normalized.length % 4));
-    const raw = Buffer.from(normalized + pad, 'base64').toString('utf8');
-    const parsed = JSON.parse(raw);
-    if (!parsed || parsed.v !== 1) return null;
-    if (!parsed.api || !parsed.upgrade || !parsed.projectId || !parsed.code) return null;
-    return parsed;
-  } catch (_) {
-    return null;
-  }
-}
-
-async function runJoin(weiyuanPath, identityPath, projectId, code) {
-  await execFileAsync('npm', ['--prefix', weiyuanPath, 'run', 'weiyuan', '--', 'join', '--identity', identityPath, '--project', projectId, '--code', code], {
-    cwd: weiyuanPath
-  });
-}
+
+const DEFAULT_SKILL_PACKAGE_JSON = {
+  name: 'weiyuan-skill-runtime',
+  private: true,
+  version: '0.0.0',
+  type: 'module',
+  scripts: {
+    weiyuan: 'tsx src/cliMain.ts',
+    'weiyuan:skill': 'tsx src/skillAdapter.ts'
+  },
+  dependencies: {
+    tweetnacl: '^1.0.3'
+  },
+  devDependencies: {
+    tsx: '^4.20.6',
+    typescript: '^5.9.3',
+    '@types/node': '^24.12.0'
+  }
+};
+
+const DEFAULT_SKILL_TSCONFIG = {
+  compilerOptions: {
+    target: 'ES2022',
+    module: 'NodeNext',
+    moduleResolution: 'NodeNext',
+    strict: true,
+    esModuleInterop: true,
+    resolveJsonModule: true,
+    skipLibCheck: true
+  },
+  include: ['src']
+};
+
+function resolveWorkspacePath(workspaceOption) {
+  const raw = (workspaceOption || DEFAULT_CONFIG.workspaceName).trim();
+  const target = path.isAbsolute(raw) ? raw : path.join(process.cwd(), raw);
+  if (path.basename(target).toLowerCase() === DEFAULT_CONFIG.workspaceName.toLowerCase()) {
+    return target;
+  }
+  return path.join(target, DEFAULT_CONFIG.workspaceName);
+}
+
+function decodeInviteToken(token) {
+  if (!token || typeof token !== 'string') return null;
+  try {
+    const normalized = token.replace(/-/g, '+').replace(/_/g, '/');
+    const pad = normalized.length % 4 === 0 ? '' : '='.repeat(4 - (normalized.length % 4));
+    const raw = Buffer.from(normalized + pad, 'base64').toString('utf8');
+    const parsed = JSON.parse(raw);
+    if (!parsed || parsed.v !== 1) return null;
+    if (!parsed.api || !parsed.upgrade || !parsed.projectId || !parsed.code) return null;
+    return parsed;
+  } catch (_) {
+    return null;
+  }
+}
+
+async function runJoin(weiyuanPath, identityPath, projectId, code) {
+  try {
+    await execFileAsync('npm', ['--prefix', weiyuanPath, 'run', 'weiyuan', '--', 'join', '--identity', identityPath, '--project', projectId, '--code', code], {
+      cwd: weiyuanPath
+    });
+    return;
+  } catch (_) {
+  }
+  await execFileAsync('npx', ['-y', '-p', 'tsx', '-p', 'tweetnacl', 'tsx', path.join(weiyuanPath, 'src', 'cliMain.ts'), 'join', '--identity', identityPath, '--project', projectId, '--code', code], {
+    cwd: weiyuanPath
+  });
+}
+
+async function ensureSkillRuntime(weiyuanPath) {
+  const pkgPath = path.join(weiyuanPath, 'package.json');
+  const tsconfigPath = path.join(weiyuanPath, 'tsconfig.json');
+  if (!await fs.pathExists(pkgPath)) {
+    await fs.writeJson(pkgPath, DEFAULT_SKILL_PACKAGE_JSON, { spaces: 2 });
+  }
+  if (!await fs.pathExists(tsconfigPath)) {
+    await fs.writeJson(tsconfigPath, DEFAULT_SKILL_TSCONFIG, { spaces: 2 });
+  }
+  await execFileAsync('npm', ['--prefix', weiyuanPath, 'install'], { cwd: weiyuanPath });
+}
+
+async function runCliInit(weiyuanPath, identityPath, serverUrl) {
+  try {
+    await execFileAsync('npm', ['--prefix', weiyuanPath, 'run', 'weiyuan', '--', 'init', '--server', serverUrl, '--out', identityPath], {
+      cwd: weiyuanPath
+    });
+    return true;
+  } catch (_) {
+  }
+  await execFileAsync('npx', ['-y', '-p', 'tsx', '-p', 'tweetnacl', 'tsx', path.join(weiyuanPath, 'src', 'cliMain.ts'), 'init', '--server', serverUrl, '--out', identityPath], {
+    cwd: weiyuanPath
+  });
+  return true;
+}
 
 async function runInit(options) {
   printBanner();
-
-  const invite = decodeInviteToken(options.invite);
-  if (invite) {
-    options.server = options.server || invite.api;
-    options.upgrade = options.upgrade || invite.upgrade;
-    options.project = options.project || invite.projectId;
-    options.code = options.code || invite.code;
-  }
-
-  const workspacePath = path.join(process.cwd(), options.workspace);
+
+  const invite = decodeInviteToken(options.invite);
+  if (invite) {
+    options.server = options.server || invite.api;
+    options.upgrade = options.upgrade || invite.upgrade;
+    options.project = options.project || invite.projectId;
+    options.code = options.code || invite.code;
+  }
+
+  const workspacePath = resolveWorkspacePath(options.workspace);
   const weiyuanPath = path.join(workspacePath, 'weiyuan');
-  const upgradeBaseUrl = options.upgrade || DEFAULT_CONFIG.upgradeBaseUrl;
-  const requestedDownloadUrl = options.download || DEFAULT_CONFIG.downloadUrl;
+  const upgradeBaseUrl = options.upgrade || DEFAULT_CONFIG.upgradeBaseUrl;
+  const requestedDownloadUrl = options.download || DEFAULT_CONFIG.downloadUrl;
   const serverUrl = options.server || DEFAULT_CONFIG.serverUrl;
   const force = options.force || false;
 
@@ -85,22 +159,22 @@ async function runInit(options) {
   }
 
   // 3. 下载文件
-  spinner = ora('解析下载包...').start();
-  const source = await resolvePackageSource({
-    downloadUrl: requestedDownloadUrl,
-    upgradeBaseUrl,
-    spinner
-  });
-  spinner.succeed(`下载源: ${source.downloadUrl}`);
-
-  spinner = ora('下载 weiyuan skill...').start();
-  const zipPath = path.join(weiyuanPath, source.zipFilename);
-  const downloadSuccess = await downloadFile(source.downloadUrl, zipPath, spinner);
+  spinner = ora('解析下载包...').start();
+  const source = await resolvePackageSource({
+    downloadUrl: requestedDownloadUrl,
+    upgradeBaseUrl,
+    spinner
+  });
+  spinner.succeed(`下载源: ${source.downloadUrl}`);
+
+  spinner = ora('下载 weiyuan skill...').start();
+  const zipPath = path.join(weiyuanPath, source.zipFilename);
+  const downloadSuccess = await downloadFile(source.downloadUrl, zipPath, spinner);
   if (!downloadSuccess) {
     spinner.fail('下载失败');
     throw new Error('下载失败');
   }
-  spinner.succeed(`下载完成: ${source.zipFilename}`);
+  spinner.succeed(`下载完成: ${source.zipFilename}`);
 
   // 4. 解压
   spinner = ora('解压文件...').start();
@@ -120,46 +194,62 @@ async function runInit(options) {
     spinner.warn('清理失败，可手动删除');
   }
 
-  // 6. 创建身份文件
+  // 6. 准备 CLI 运行时
+  spinner = ora('准备 CLI 运行时...').start();
+  try {
+    await ensureSkillRuntime(weiyuanPath);
+    spinner.succeed('CLI 运行时就绪');
+  } catch (error) {
+    spinner.fail(`CLI 运行时准备失败: ${error.message}`);
+    throw error;
+  }
+
+  // 7. 创建身份文件
   spinner = ora('创建身份文件...').start();
   const identityPath = path.join(workspacePath, DEFAULT_CONFIG.identityFile);
-  const identityCreated = await createIdentityFile(identityPath, serverUrl, workspacePath);
+  let identityCreated = false;
+  try {
+    identityCreated = await runCliInit(weiyuanPath, identityPath, serverUrl);
+  } catch (_) {
+    identityCreated = await createIdentityFile(identityPath, serverUrl, workspacePath);
+  }
   if (identityCreated) {
     spinner.succeed(`身份文件: ${DEFAULT_CONFIG.identityFile}`);
   } else {
-    spinner.warn('身份文件创建失败，请手动创建');
+    spinner.fail('身份文件创建失败，请检查 /v1/init 可用性');
+    throw new Error('identity_create_failed');
   }
 
-  // 7. 列出目录内容
+  // 8. 列出目录内容
   console.log(chalk.yellow('\n📁 weiyuan 文件夹内容:'));
   await listDirectory(weiyuanPath, 10);
 
-  // 8. 初始化 skill
+  // 9. 初始化 skill
   spinner = ora('初始化 weiyuan skill...').start();
   const initResult = await initSkill(serverUrl, identityPath, workspacePath);
   if (initResult) {
     spinner.succeed('初始化成功');
   } else {
-    spinner.warn('初始化端点不存在，请手动调用');
-  }
-
-  if (options.project && options.code) {
-    spinner = ora('自动加入微元项目...').start();
-    try {
-      await runJoin(weiyuanPath, identityPath, options.project, options.code);
-      spinner.succeed(`已加入项目: ${options.project}`);
-    } catch (error) {
-      spinner.fail(`自动入组失败: ${error.message}`);
-      throw error;
-    }
-  }
+    spinner.warn('初始化端点不存在，可忽略（不影响 join/命令执行）');
+  }
+
+  if (options.project && options.code) {
+    spinner = ora('自动加入微元项目...').start();
+    try {
+      await runJoin(weiyuanPath, identityPath, options.project, options.code);
+      spinner.succeed(`已加入项目: ${options.project}`);
+    } catch (error) {
+      spinner.fail(`自动入组失败: ${error.message}`);
+      throw error;
+    }
+  }
 
   // 打印总结
-  printSummary(workspacePath, serverUrl, source.downloadUrl);
+  printSummary(workspacePath, serverUrl, source.downloadUrl);
 }
 
 async function runClean(options) {
-  const workspacePath = path.join(process.cwd(), options.workspace);
+  const workspacePath = resolveWorkspacePath(options.workspace);
 
   if (!await fs.pathExists(workspacePath)) {
     console.log(chalk.yellow(`工作目录不存在: ${workspacePath}`));
@@ -177,7 +267,7 @@ async function runClean(options) {
 }
 
 async function runStatus(options) {
-  const workspacePath = path.join(process.cwd(), options.workspace);
+  const workspacePath = resolveWorkspacePath(options.workspace);
   const weiyuanPath = path.join(workspacePath, 'weiyuan');
   const identityPath = path.join(workspacePath, DEFAULT_CONFIG.identityFile);
 
@@ -205,21 +295,22 @@ async function runStatus(options) {
   // 检查身份文件
   if (await fs.pathExists(identityPath)) {
     const identity = await fs.readJson(identityPath);
-    console.log(chalk.green(`✅ 身份文件: ${identity.device_id || '已配置'}`));
+    const idLabel = identity.lobsterId || identity.device_id || '已配置';
+    console.log(chalk.green(`✅ 身份文件: ${idLabel}`));
   } else {
     console.log(chalk.red(`❌ 身份文件不存在`));
   }
 
   // 检查服务器
-  const serverUrl = options.server || DEFAULT_CONFIG.serverUrl;
-  const serverOk = await checkServer(serverUrl);
+  const serverUrl = options.server || DEFAULT_CONFIG.serverUrl;
+  const serverOk = await checkServer(serverUrl);
   if (serverOk) {
-    console.log(chalk.green(`✅ 服务器: ${serverUrl}`));
+    console.log(chalk.green(`✅ 服务器: ${serverUrl}`));
   } else {
-    console.log(chalk.red(`❌ 服务器不可达: ${serverUrl}`));
+    console.log(chalk.red(`❌ 服务器不可达: ${serverUrl}`));
   }
 
   console.log('');
 }
 
-module.exports = { runInit, runClean, runStatus, DEFAULT_CONFIG };
+module.exports = { runInit, runClean, runStatus, DEFAULT_CONFIG };

package/lib/downloader.js

@@ -1,36 +1,36 @@
 const axios = require('axios');
 const fs = require('fs-extra');
 
-function trimSlash(url) {
-  return String(url || '').replace(/\/+$/, '');
-}
-
-function toZipFilename(downloadUrl) {
-  const clean = String(downloadUrl || '').split('?')[0].split('#')[0];
-  const parts = clean.split('/');
-  return parts[parts.length - 1] || 'weiyuan-openclaw-skill.zip';
-}
-
-async function resolvePackageSource({ downloadUrl, upgradeBaseUrl, spinner = null }) {
-  if (downloadUrl) {
-    return { downloadUrl, zipFilename: toZipFilename(downloadUrl), version: null, from: 'download_url' };
-  }
-
-  const base = trimSlash(upgradeBaseUrl);
-  const latestUrl = `${base}/LATEST_SKILL_VERSION.txt`;
-  const latestResp = await axios.get(latestUrl, { timeout: 10000 });
-  const version = String(latestResp.data || '').trim();
-  if (!version) {
-    throw new Error('empty_latest_version');
-  }
-  const zipFilename = `weiyuan-openclaw-skill-v${version}.zip`;
-  const resolvedDownloadUrl = `${base}/${zipFilename}`;
-  if (spinner) {
-    spinner.text = `已解析最新版本: v${version}`;
-  }
-  return { downloadUrl: resolvedDownloadUrl, zipFilename, version, from: 'latest_version' };
-}
-
+function trimSlash(url) {
+  return String(url || '').replace(/\/+$/, '');
+}
+
+function toZipFilename(downloadUrl) {
+  const clean = String(downloadUrl || '').split('?')[0].split('#')[0];
+  const parts = clean.split('/');
+  return parts[parts.length - 1] || 'weiyuan-openclaw-skill.zip';
+}
+
+async function resolvePackageSource({ downloadUrl, upgradeBaseUrl, spinner = null }) {
+  if (downloadUrl) {
+    return { downloadUrl, zipFilename: toZipFilename(downloadUrl), version: null, from: 'download_url' };
+  }
+
+  const base = trimSlash(upgradeBaseUrl);
+  const latestUrl = `${base}/LATEST_SKILL_VERSION.txt`;
+  const latestResp = await axios.get(latestUrl, { timeout: 10000 });
+  const version = String(latestResp.data || '').trim();
+  if (!version) {
+    throw new Error('empty_latest_version');
+  }
+  const zipFilename = `weiyuan-openclaw-skill-v${version}.zip`;
+  const resolvedDownloadUrl = `${base}/${zipFilename}`;
+  if (spinner) {
+    spinner.text = `已解析最新版本: v${version}`;
+  }
+  return { downloadUrl: resolvedDownloadUrl, zipFilename, version, from: 'latest_version' };
+}
+
 async function downloadFile(url, outputPath, spinner = null) {
   try {
     const response = await axios({
@@ -70,4 +70,4 @@ async function downloadFile(url, outputPath, spinner = null) {
   }
 }
 
-module.exports = { downloadFile, resolvePackageSource };
+module.exports = { downloadFile, resolvePackageSource };

package/lib/identity.js

@@ -1,39 +1,110 @@
-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 };
+const fs = require('fs-extra');
+const os = require('os');
+const crypto = require('crypto');
+const axios = require('axios');
+const naclImport = require('tweetnacl');
+
+const nacl = naclImport.default || naclImport;
+
+function sha256Hex(input) {
+  return crypto.createHash('sha256').update(input).digest('hex');
+}
+
+function sha256Base64(input) {
+  return crypto.createHash('sha256').update(input).digest('base64');
+}
+
+function canonicalRequest(method, pathWithQuery, timestampMs, nonce, bodySha256Base64) {
+  return [String(method || 'POST').toUpperCase(), pathWithQuery, timestampMs, nonce, bodySha256Base64].join('\n');
+}
+
+function signEd25519Base64(messageUtf8, secretKeyBase64) {
+  const sk = Buffer.from(secretKeyBase64, 'base64');
+  const sig = nacl.sign.detached(Buffer.from(messageUtf8, 'utf8'), sk);
+  return Buffer.from(sig).toString('base64');
+}
+
+function newKeyPair() {
+  const kp = nacl.sign.keyPair();
+  const publicKeyBase64 = Buffer.from(kp.publicKey).toString('base64');
+  const secretKeyBase64 = Buffer.from(kp.secretKey).toString('base64');
+  const lobsterId = `lob_${sha256Hex(kp.publicKey).slice(0, 12)}`;
+  return { publicKeyBase64, secretKeyBase64, lobsterId };
+}
+
+async function registerIdentity(serverUrl, identity) {
+  const body = {
+    lobsterId: identity.lobsterId,
+    publicKeyBase64: identity.publicKeyBase64,
+    identityHash: identity.identityHash
+  };
+  const timestampMs = String(Date.now());
+  const nonce = `nonce_${Math.random().toString(16).slice(2)}`;
+  const bodySha256Base64 = sha256Base64(JSON.stringify(body));
+  const canonical = canonicalRequest('POST', '/v1/init', timestampMs, nonce, bodySha256Base64);
+  const signature = signEd25519Base64(canonical, identity.secretKeyBase64);
+
+  const res = await axios.post(`${serverUrl.replace(/\/$/, '')}/v1/init`, body, {
+    headers: {
+      'Content-Type': 'application/json',
+      'X-Weiyuan-Lobster-Id': identity.lobsterId,
+      'X-Weiyuan-Timestamp': timestampMs,
+      'X-Weiyuan-Nonce': nonce,
+      'X-Weiyuan-Signature': signature
+    },
+    timeout: 12000,
+    validateStatus: () => true
+  });
+  if (res.status !== 200) {
+    throw new Error(`identity_register_failed_status_${res.status}`);
+  }
+}
+
+async function createIdentityFile(identityPath, serverUrl, workspacePath) {
+  try {
+    if (await fs.pathExists(identityPath)) {
+      const existing = await fs.readJson(identityPath).catch(() => ({}));
+      if (existing && existing.version === 1 && existing.lobsterId && existing.secretKeyBase64 && existing.publicKeyBase64) {
+        return true;
+      }
+    }
+
+    const kp = newKeyPair();
+    const identityHash = sha256Hex(JSON.stringify({ lobsterId: kp.lobsterId, publicKeyBase64: kp.publicKeyBase64 }));
+    const identity = {
+      version: 1,
+      serverBaseUrl: serverUrl,
+      lobsterId: kp.lobsterId,
+      publicKeyBase64: kp.publicKeyBase64,
+      secretKeyBase64: kp.secretKeyBase64,
+      identityHash,
+      projectCursors: {},
+      meta: {
+        device_id: os.hostname(),
+        device_name: os.hostname(),
+        created_at: new Date().toISOString(),
+        workspace: workspacePath,
+        skill_path: `${workspacePath}/weiyuan`
+      }
+    };
+
+    await registerIdentity(serverUrl, identity);
+    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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-weiyuan-init",
-  "version": "1.0.5",
+  "version": "1.0.13",
   "description": "OpenClaw Weiyuan Skill 一键初始化工具",
   "main": "bin/cli.js",
   "bin": {
@@ -20,7 +20,8 @@
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
     "fs-extra": "^11.1.1",
-    "ora": "^5.4.1"
+    "ora": "^5.4.1",
+    "tweetnacl": "^1.0.3"
   },
   "publishConfig": {
     "access": "public"