@xfxstudio/claworld 2026.4.21-testing.1 → 2026.4.21-testing.2

package/openclaw.plugin.json

@@ -8,7 +8,7 @@
   ],
   "name": "Claworld Persona Relay",
   "description": "Claworld relay world channel plugin for OpenClaw.",
-  "version": "2026.4.21-testing.1",
+  "version": "2026.4.21-testing.2",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xfxstudio/claworld",
-  "version": "2026.4.21-testing.1",
+  "version": "2026.4.21-testing.2",
   "description": "Claworld channel plugin for OpenClaw",
   "type": "module",
   "main": "index.js",

package/src/openclaw/runtime/feedback-diagnostics.js

@@ -1,4 +1,3 @@
-import { detectOpenclawHost } from '../host-version.js';
 import { CLAWORLD_PLUGIN_CURRENT_VERSION } from '../plugin-version.js';
 import { getClaworldRuntime } from '../plugin/runtime.js';
 
@@ -123,6 +122,7 @@ const MODEL_ID_PATHS = [
 ];
 
 const OPENCLAW_VERSION_PATHS = [
+  ['version'],
   ['host', 'version'],
   ['openclaw', 'version'],
   ['meta', 'hostVersion'],
@@ -150,18 +150,8 @@ function resolveModelDiagnostics(sources = []) {
   };
 }
 
-let cachedOpenclawVersionPromise = null;
-
-async function detectOpenclawVersion(runtime = null) {
-  const exposedVersion = pickDiagnosticValue([runtime], OPENCLAW_VERSION_PATHS, normalizeText);
-  if (exposedVersion) return exposedVersion;
-  if (!runtime) return null;
-  if (!cachedOpenclawVersionPromise) {
-    cachedOpenclawVersionPromise = detectOpenclawHost()
-      .then((result) => normalizeText(result?.version, null))
-      .catch(() => null);
-  }
-  return cachedOpenclawVersionPromise;
+function detectOpenclawVersion(runtime = null) {
+  return pickDiagnosticValue([runtime], OPENCLAW_VERSION_PATHS, normalizeText);
 }
 
 export async function collectFeedbackDiagnostics({
@@ -170,10 +160,8 @@ export async function collectFeedbackDiagnostics({
   pluginVersion = null,
 } = {}) {
   const resolvedRuntime = resolveRuntimeCandidate(runtime);
-  const [loadedConfig, openclawVersion] = await Promise.all([
-    loadRuntimeConfig(resolvedRuntime),
-    detectOpenclawVersion(resolvedRuntime),
-  ]);
+  const loadedConfig = await loadRuntimeConfig(resolvedRuntime);
+  const openclawVersion = detectOpenclawVersion(resolvedRuntime);
   const modelDiagnostics = resolveModelDiagnostics([
     resolvedRuntime,
     loadedConfig,

package/src/openclaw/host-version.js

@@ -1,222 +0,0 @@
-import { accessSync, constants as FS_CONSTANTS } from 'fs';
-import path from 'path';
-import { spawnSync } from 'child_process';
-
-export const DEFAULT_OPENCLAW_BIN = 'openclaw';
-
-function normalizeText(value, fallback = null) {
-  if (value == null) return fallback;
-  const normalized = String(value).trim();
-  return normalized || fallback;
-}
-
-function createOpenclawVersionError(code, message, context = {}) {
-  const error = new Error(message);
-  error.code = code;
-  error.context = context;
-  return error;
-}
-
-function isExplicitCommandPath(command = '') {
-  const normalized = String(command || '').trim();
-  if (!normalized) return false;
-  return normalized.includes('/') || normalized.includes('\\') || path.isAbsolute(normalized);
-}
-
-function splitPathEnvEntries(pathValue = '') {
-  return String(pathValue || '')
-    .split(path.delimiter)
-    .map((entry) => entry.trim())
-    .filter(Boolean);
-}
-
-function isNodeModulesBinEntry(entry = '') {
-  const normalized = path.resolve(String(entry || ''));
-  return path.basename(normalized) === '.bin'
-    && path.basename(path.dirname(normalized)) === 'node_modules';
-}
-
-function resolveCommandNameCandidates(command = '', env = process.env) {
-  const normalized = String(command || '').trim();
-  if (!normalized) return [];
-  if (process.platform !== 'win32' || path.extname(normalized)) {
-    return [normalized];
-  }
-
-  const pathExt = splitPathEnvEntries(env?.PATHEXT || process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD')
-    .map((ext) => ext.toLowerCase());
-  return [...new Set([normalized, ...pathExt.map((ext) => `${normalized}${ext}`)])];
-}
-
-function hasExecutableAccess(filePath = '') {
-  try {
-    accessSync(filePath, FS_CONSTANTS.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function resolveOpenclawCliBinary({
-  openclawBin = DEFAULT_OPENCLAW_BIN,
-  env = process.env,
-} = {}) {
-  const requestedBin = normalizeText(openclawBin, DEFAULT_OPENCLAW_BIN);
-  if (
-    requestedBin !== DEFAULT_OPENCLAW_BIN
-    || isExplicitCommandPath(requestedBin)
-  ) {
-    return {
-      requestedBin,
-      binaryPath: requestedBin,
-      binarySource: isExplicitCommandPath(requestedBin) ? 'explicit_path' : 'explicit_command',
-      skippedLocalBinaryPaths: [],
-    };
-  }
-
-  const candidates = [];
-  for (const entry of splitPathEnvEntries(env?.PATH || process.env.PATH || '')) {
-    for (const name of resolveCommandNameCandidates(requestedBin, env)) {
-      const candidatePath = path.join(entry, name);
-      if (hasExecutableAccess(candidatePath)) {
-        candidates.push(candidatePath);
-      }
-    }
-  }
-
-  const uniqueCandidates = [...new Set(candidates)];
-  const hostCandidates = uniqueCandidates.filter((candidate) => !isNodeModulesBinEntry(path.dirname(candidate)));
-  const localCandidates = uniqueCandidates.filter((candidate) => isNodeModulesBinEntry(path.dirname(candidate)));
-  const binaryPath = hostCandidates[0] || uniqueCandidates[0] || requestedBin;
-
-  return {
-    requestedBin,
-    binaryPath,
-    binarySource: hostCandidates[0]
-      ? 'host_path'
-      : uniqueCandidates[0]
-        ? 'package_local_path'
-        : 'default_command',
-    skippedLocalBinaryPaths: localCandidates.filter((candidate) => candidate !== binaryPath),
-  };
-}
-
-function defaultCommandRunner({
-  bin,
-  args = [],
-  cwd = process.cwd(),
-  env = process.env,
-} = {}) {
-  const result = spawnSync(bin, args, {
-    cwd,
-    env,
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'pipe'],
-    shell: false,
-    windowsHide: true,
-  });
-  if (result.error) throw result.error;
-  return {
-    status: Number.isInteger(result.status) ? result.status : 1,
-    stdout: result.stdout || '',
-    stderr: result.stderr || '',
-  };
-}
-
-function parseCommandVersion(text) {
-  const match = String(text || '').match(/OpenClaw\s+([0-9]+(?:\.[0-9]+)+(?:-[0-9A-Za-z.-]+)?)/i)
-    || String(text || '').match(/([0-9]+(?:\.[0-9]+)+(?:-[0-9A-Za-z.-]+)?)/);
-  return match ? match[1] : null;
-}
-
-async function executeCommand({
-  commandRunner = defaultCommandRunner,
-  bin,
-  args = [],
-  cwd = process.cwd(),
-  env = process.env,
-  dryRun = false,
-  } = {}) {
-  const resolvedBin = resolveOpenclawCliBinary({
-    openclawBin: bin,
-    env,
-  });
-  const effectiveBin = commandRunner === defaultCommandRunner
-    ? resolvedBin.binaryPath
-    : resolvedBin.requestedBin;
-  if (dryRun) {
-    return {
-      status: 0,
-      stdout: '',
-      stderr: '',
-      requestedBin: resolvedBin.requestedBin,
-      resolvedBin: resolvedBin.binaryPath,
-      binSource: resolvedBin.binarySource,
-      skippedBinCandidates: resolvedBin.skippedLocalBinaryPaths,
-    };
-  }
-
-  let result;
-  try {
-    result = await commandRunner({
-      bin: effectiveBin,
-      args,
-      cwd,
-      env,
-    });
-  } catch (error) {
-    throw createOpenclawVersionError(
-      'openclaw_command_failed',
-      error?.message || String(error),
-      {
-        bin: resolvedBin.binaryPath,
-        args,
-      },
-    );
-  }
-
-  return {
-    status: Number.isInteger(result?.status) ? result.status : 1,
-    stdout: result?.stdout || '',
-    stderr: result?.stderr || '',
-    requestedBin: resolvedBin.requestedBin,
-    resolvedBin: resolvedBin.binaryPath,
-    binSource: resolvedBin.binarySource,
-    skippedBinCandidates: resolvedBin.skippedLocalBinaryPaths,
-  };
-}
-
-export async function detectOpenclawHost({
-  openclawBin = DEFAULT_OPENCLAW_BIN,
-  commandRunner = defaultCommandRunner,
-  cwd = process.cwd(),
-  env = process.env,
-  dryRun = false,
-} = {}) {
-  const result = await executeCommand({
-    commandRunner,
-    bin: openclawBin,
-    args: ['--version'],
-    cwd,
-    env,
-    dryRun,
-  });
-  const version = parseCommandVersion(result.stdout || result.stderr);
-  if (!version) {
-    throw createOpenclawVersionError(
-      'openclaw_version_unreadable',
-      'Unable to determine the installed OpenClaw version.',
-      { result },
-    );
-  }
-  return {
-    version,
-    raw: (result.stdout || result.stderr || '').trim(),
-    requestedBin: result.requestedBin || openclawBin,
-    binaryPath: result.resolvedBin || openclawBin,
-    binarySource: result.binSource || 'default_command',
-    skippedLocalBinaryPaths: Array.isArray(result.skippedBinCandidates)
-      ? result.skippedBinCandidates
-      : [],
-  };
-}