openclaw-weiyuan-init 1.0.118 → 1.0.127

package/bin/cli.js

@@ -3,11 +3,12 @@
 const { program } = require('commander');
 const chalk = require('chalk');
 const { runInit, runClean, runStatus } = require('../lib/commands');
+const { version } = require('../package.json');
 
 program
   .name('openclaw-weiyuan-init')
   .description('OpenClaw Weiyuan Skill 一键初始化工具')
-  .version('1.0.0');
+  .version(version);
 
 program
   .command('init')

package/lib/commands.js

@@ -60,6 +60,15 @@ const DEFAULT_SKILL_TSCONFIG = {
 
 const REQUIRED_SKILL_ACTIONS = ['project.list', 'task.list_all', 'context.candidates'];
 
+function cleanCliRawText(raw) {
+  if (raw === undefined || raw === null) return '';
+  let text = String(raw).replace(/\r|\n/g, ' ').replace(/`/g, '').trim();
+  while ((text.startsWith('"') && text.endsWith('"')) || (text.startsWith("'") && text.endsWith("'"))) {
+    text = text.slice(1, -1).trim();
+  }
+  return text;
+}
+
 function bundledSkillMetadataPath(fileName) {
   return path.join(__dirname, '..', 'workspace-weiyuan', 'weiyuan', fileName);
 }
@@ -447,7 +456,19 @@ async function persistReleaseNotes(weiyuanPath, notes) {
 
 function resolveWorkspacePath(workspaceOption) {
   const raw = (workspaceOption || DEFAULT_CONFIG.workspaceName).trim();
-  const target = path.isAbsolute(raw) ? raw : path.join(process.cwd(), raw);
+  const cwd = process.cwd();
+  const workspaceName = DEFAULT_CONFIG.workspaceName.toLowerCase();
+  const cwdBase = path.basename(cwd).toLowerCase();
+  const rawParts = raw.replace(/\\/g, '/').split('/').map((x) => String(x || '').trim()).filter(Boolean);
+  if (cwdBase === workspaceName) {
+    if (!raw || raw === '.' || raw === './' || raw === '.\\') {
+      return cwd;
+    }
+    if (rawParts.length > 0 && rawParts.every((part) => part.toLowerCase() === workspaceName)) {
+      return cwd;
+    }
+  }
+  const target = path.isAbsolute(raw) ? raw : path.join(cwd, raw);
   if (path.basename(target).toLowerCase() === DEFAULT_CONFIG.workspaceName.toLowerCase()) {
     return target;
   }
@@ -457,7 +478,7 @@ function resolveWorkspacePath(workspaceOption) {
 function decodeInviteToken(token) {
   if (!token || typeof token !== 'string') return null;
   try {
-    const normalized = token.replace(/-/g, '+').replace(/_/g, '/');
+    const normalized = cleanCliRawText(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);
@@ -481,9 +502,10 @@ function decodeInviteToken(token) {
 }
 
 function normalizeServerUrl(raw) {
-  if (!raw || typeof raw !== 'string') return '';
+  const cleaned = cleanCliRawText(raw);
+  if (!cleaned) return '';
   try {
-    const url = new URL(raw.trim());
+    const url = new URL(cleaned);
     const p = (url.pathname || '/').replace(/\/+$/, '');
     if (!p || p === '/') url.pathname = '/api';
     url.hash = '';
@@ -493,6 +515,30 @@ function normalizeServerUrl(raw) {
   }
 }
 
+function normalizeUpgradeUrl(raw) {
+  const cleaned = cleanCliRawText(raw);
+  if (!cleaned) return '';
+  try {
+    const url = new URL(cleaned);
+    url.hash = '';
+    return url.toString().replace(/\/+$/, '');
+  } catch (_) {
+    return '';
+  }
+}
+
+function normalizeDownloadUrl(raw) {
+  const cleaned = cleanCliRawText(raw);
+  if (!cleaned) return '';
+  try {
+    const url = new URL(cleaned);
+    url.hash = '';
+    return url.toString();
+  } catch (_) {
+    return '';
+  }
+}
+
 function isAgentRegisterServerUrl(raw) {
   if (!raw || typeof raw !== 'string') return false;
   try {
@@ -641,6 +687,7 @@ async function printAgentConversationGuide(identityPath, projectId) {
 async function ensureSkillRuntime(weiyuanPath) {
   const pkgPath = path.join(weiyuanPath, 'package.json');
   const tsconfigPath = path.join(weiyuanPath, 'tsconfig.json');
+  const bundledManifestPath = bundledSkillMetadataPath('manifest.json');
   const capabilityCompatContent = `export const CAPABILITY_ACTION = {
   PROJECT_DELETE: "project.delete",
   TASK_DELETE: "task.delete",
@@ -656,8 +703,15 @@ async function ensureSkillRuntime(weiyuanPath) {
 
 export const CAPABILITY_ACTION_ALLOWLIST = new Set<string>(Object.values(CAPABILITY_ACTION))
 `;
+  let fallbackPackageJson = { ...DEFAULT_SKILL_PACKAGE_JSON };
+  try {
+    const bundledManifest = await fs.readJson(bundledManifestPath);
+    const bundledVersion = String(bundledManifest && bundledManifest.version || '').trim();
+    if (bundledVersion) fallbackPackageJson = { ...fallbackPackageJson, version: bundledVersion };
+  } catch (_) {
+  }
   if (!await fs.pathExists(pkgPath)) {
-    await fs.writeJson(pkgPath, DEFAULT_SKILL_PACKAGE_JSON, { spaces: 2 });
+    await fs.writeJson(pkgPath, fallbackPackageJson, { spaces: 2 });
   }
   if (!await fs.pathExists(tsconfigPath)) {
     await fs.writeJson(tsconfigPath, DEFAULT_SKILL_TSCONFIG, { spaces: 2 });
@@ -706,10 +760,16 @@ async function runInit(options) {
   printBanner();
   const fixedMessages = getFixedMessages();
   let initIdentityInfo = null;
+  options = options || {};
+  options.server = cleanCliRawText(options.server || '');
+  options.upgrade = cleanCliRawText(options.upgrade || '');
+  options.download = cleanCliRawText(options.download || '');
+  options.invite = cleanCliRawText(options.invite || '');
+  options.project = cleanCliRawText(options.project || '');
+  options.code = cleanCliRawText(options.code || '');
 
   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;
@@ -717,8 +777,8 @@ async function runInit(options) {
 
   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 = normalizeUpgradeUrl(options.upgrade || DEFAULT_CONFIG.upgradeBaseUrl) || DEFAULT_CONFIG.upgradeBaseUrl;
+  const requestedDownloadUrl = normalizeDownloadUrl(options.download || DEFAULT_CONFIG.downloadUrl);
   const serverCandidates = resolveServerCandidates(options, invite);
   let serverUrl = serverCandidates[0] || DEFAULT_CONFIG.serverUrl;
   const force = options.force || false;
@@ -810,42 +870,57 @@ async function runInit(options) {
     spinner = ora('检测到已有 weiyuan 运行目录，跳过下载与解压...').start();
     spinner.succeed('已复用现有 weiyuan 目录');
   } else {
-    spinner = ora('解析下载包...').start();
-    const source = await resolvePackageSource({
-      downloadUrl: requestedDownloadUrl,
-      upgradeBaseUrl,
-      spinner
-    });
-    spinner.succeed(`下载源: ${source.downloadUrl}`);
-    printReleaseNotes(source.releaseNotes);
-
-    spinner = ora('下载 weiyuan skill...').start();
-    const zipPath = path.join(weiyuanPath, source.zipFilename);
-    const downloadSuccess = await downloadFile(source.downloadUrl, zipPath, spinner, source.sha256 || '');
-    if (!downloadSuccess) {
-      spinner.fail('下载失败');
-      throw new Error('下载失败');
-    }
-    spinner.succeed(`下载完成: ${source.zipFilename}`);
-
-    // 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);
-      await persistReleaseNotes(weiyuanPath, source.releaseNotes || null);
-      spinner.succeed('清理完成');
-    } catch (error) {
-      spinner.warn('清理失败，可手动删除');
+    const maxDownloadAttempts = 2;
+    let downloadCompleted = false;
+    let lastDownloadError = null;
+    for (let attempt = 1; attempt <= maxDownloadAttempts; attempt += 1) {
+      let source = null;
+      let zipPath = '';
+      try {
+        spinner = ora(attempt > 1 ? `重新解析下载包（第 ${attempt} 次）...` : '解析下载包...').start();
+        source = await resolvePackageSource({
+          downloadUrl: requestedDownloadUrl,
+          upgradeBaseUrl,
+          spinner
+        });
+        spinner.succeed(`下载源: ${source.downloadUrl}`);
+        printReleaseNotes(source.releaseNotes);
+
+        spinner = ora(attempt > 1 ? `重新下载 weiyuan skill（第 ${attempt} 次）...` : '下载 weiyuan skill...').start();
+        zipPath = path.join(weiyuanPath, source.zipFilename);
+        await fs.remove(zipPath).catch(() => {});
+        const downloadSuccess = await downloadFile(source.downloadUrl, zipPath, spinner, source.sha256 || '');
+        if (!downloadSuccess) throw new Error('下载失败');
+        spinner.succeed(`下载完成: ${source.zipFilename}`);
+
+        spinner = ora('解压文件...').start();
+        const extractSuccess = await extractZip(zipPath, weiyuanPath);
+        if (!extractSuccess) throw new Error('解压失败');
+        spinner.succeed('解压完成');
+
+        spinner = ora('清理临时文件...').start();
+        try {
+          await fs.remove(zipPath);
+          await persistReleaseNotes(weiyuanPath, source.releaseNotes || null);
+          spinner.succeed('清理完成');
+        } catch (error) {
+          spinner.warn('清理失败，可手动删除');
+        }
+        downloadCompleted = true;
+        lastDownloadError = null;
+        break;
+      } catch (error) {
+        lastDownloadError = error;
+        if (zipPath) await fs.remove(zipPath).catch(() => {});
+        const msg = String(error && error.message || error || '');
+        const canRetry = attempt < maxDownloadAttempts && msg.includes('skill_package_hash_mismatch');
+        if (spinner) {
+          spinner.warn(canRetry ? '下载包哈希校验未通过，正在重新获取最新版本后重试...' : `下载失败：${msg || 'unknown_error'}`);
+        }
+        if (!canRetry) throw error;
+      }
     }
+    if (!downloadCompleted && lastDownloadError) throw lastDownloadError;
   }
 
   // 6. 准备 CLI 运行时

package/lib/identity.js

@@ -1,5 +1,6 @@
 const fs = require('fs-extra');
 const os = require('os');
+const path = require('path');
 const crypto = require('crypto');
 const axios = require('axios');
 const naclImport = require('tweetnacl');
@@ -64,12 +65,66 @@ function normalizeBusinessServerUrl(serverUrl) {
   }
 }
 
-async function registerIdentity(serverUrl, identity) {
+function applyIdentityProxyMetadata(identity, initInfo) {
+  const next = identity && typeof identity === 'object' ? { ...identity } : {};
+  const lobsterId = String(next.lobsterId || '').trim();
+  const effectiveLobsterId = String(initInfo && initInfo.effectiveLobsterId || '').trim();
+  const ownerLobsterId = String(initInfo && initInfo.ownerLobsterId || '').trim();
+  const accountModeRaw = String(initInfo && initInfo.accountMode || initInfo && initInfo.mode || '').trim();
+  const accountMode = accountModeRaw === 'agent' || accountModeRaw === 'owner' ? accountModeRaw : '';
+  const accountTypeRaw = String(initInfo && initInfo.accountType || '').trim().toLowerCase();
+  const accountType = accountTypeRaw === 'auto' || accountTypeRaw === 'weiyuan' || accountTypeRaw === 'lob' ? accountTypeRaw : '';
+  const displayAccountId = String((initInfo && (initInfo.displayAccountId || initInfo.account)) || '').trim();
+  if (effectiveLobsterId && effectiveLobsterId !== lobsterId) next.effectiveLobsterId = effectiveLobsterId;
+  else delete next.effectiveLobsterId;
+  if (ownerLobsterId && ownerLobsterId !== lobsterId) next.ownerLobsterId = ownerLobsterId;
+  else delete next.ownerLobsterId;
+  if (accountMode) next.accountMode = accountMode;
+  else delete next.accountMode;
+  if (accountType) next.accountType = accountType;
+  else delete next.accountType;
+  if (displayAccountId) next.displayAccountId = displayAccountId;
+  else delete next.displayAccountId;
+  return next;
+}
+
+function normalizeSkillVersionText(raw) {
+  const text = String(raw || '').trim().replace(/^v/i, '');
+  return text && text !== '0.0.0' ? text : '';
+}
+
+async function readLocalSkillVersion(workspacePath) {
+  const weiyuanPath = path.join(String(workspacePath || ''), 'weiyuan');
+  const candidates = [
+    path.join(weiyuanPath, 'package.json'),
+    path.join(weiyuanPath, 'release-notes', 'latest.json'),
+    path.join(weiyuanPath, 'manifest.json'),
+  ];
+  for (const file of candidates) {
+    try {
+      const parsed = await fs.readJson(file);
+      const version = normalizeSkillVersionText(parsed && parsed.version);
+      if (version) return version;
+    } catch (_) {
+    }
+  }
+  try {
+    const plain = await fs.readFile(path.join(weiyuanPath, '.version'), 'utf8');
+    const version = normalizeSkillVersionText(plain);
+    if (version) return version;
+  } catch (_) {
+  }
+  return '';
+}
+
+async function registerIdentity(serverUrl, identity, workspacePath) {
+  const skillVersion = await readLocalSkillVersion(workspacePath);
   const body = {
     lobsterId: identity.lobsterId,
     publicKeyBase64: identity.publicKeyBase64,
     identityHash: identity.identityHash,
-    recoveryHint: identity && identity.meta ? identity.meta.recoveryHint : undefined
+    recoveryHint: identity && identity.meta ? identity.meta.recoveryHint : undefined,
+    skillVersion: skillVersion || undefined
   };
   const timestampMs = String(Date.now());
   const nonce = `nonce_${Math.random().toString(16).slice(2)}`;
@@ -127,7 +182,7 @@ async function createIdentityFile(identityPath, serverUrl, workspacePath) {
             recoveryHint: (existing.meta && existing.meta.recoveryHint) || buildRecoveryHint(workspacePath)
           }
         };
-        const initInfo = await registerIdentity(serverUrl, identity);
+        const initInfo = await registerIdentity(serverUrl, identity, workspacePath);
         const serverLobsterId = String(initInfo && initInfo.lobsterId || '').trim();
         if (serverLobsterId) {
           identity.lobsterId = serverLobsterId;
@@ -151,7 +206,8 @@ async function createIdentityFile(identityPath, serverUrl, workspacePath) {
                   .filter(([k, v]) => k && Number.isFinite(v))
               )
             : {};
-        await fs.writeJson(identityPath, identity, { spaces: 2 });
+        const nextIdentity = applyIdentityProxyMetadata(identity, initInfo);
+        await fs.writeJson(identityPath, nextIdentity, { spaces: 2 });
         return { created: true, initInfo: initInfo || null };
       }
     }
@@ -176,7 +232,7 @@ async function createIdentityFile(identityPath, serverUrl, workspacePath) {
       }
     };
 
-    const initInfo = await registerIdentity(serverUrl, identity);
+    const initInfo = await registerIdentity(serverUrl, identity, workspacePath);
     const serverLobsterId = String(initInfo && initInfo.lobsterId || '').trim();
     if (serverLobsterId) {
       identity.lobsterId = serverLobsterId;
@@ -200,7 +256,8 @@ async function createIdentityFile(identityPath, serverUrl, workspacePath) {
               .filter(([k, v]) => k && Number.isFinite(v))
           )
         : {};
-    await fs.writeJson(identityPath, identity, { spaces: 2 });
+    const nextIdentity = applyIdentityProxyMetadata(identity, initInfo);
+    await fs.writeJson(identityPath, nextIdentity, { spaces: 2 });
     return { created: true, initInfo: initInfo || null };
   } catch (error) {
     return { created: false, initInfo: null, error: error && error.message ? String(error.message) : 'identity_create_failed' };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-weiyuan-init",
-  "version": "1.0.118",
+  "version": "1.0.127",
   "description": "OpenClaw Weiyuan Skill 一键初始化工具",
   "main": "bin/cli.js",
   "bin": {