rol-websocket-channel 1.7.3 → 1.7.5

package/index.ts

@@ -67,6 +67,20 @@ export function getPluginRuntime(): any {
   return pluginRuntime;
 }
 
+// Chinese translations keyed by error code, so CLI failures are returned
+// bilingually (English `message` + Chinese `messageZh`).
+const ERROR_MESSAGES_ZH: Record<string, string> = {
+  PAIR_KEY_REQUIRED: "配对码不能为空",
+  PAIR_CONFIG_NOT_FOUND:
+    "找不到 openclaw.json 配置文件(请确认插件位于 OpenClaw 安装目录内,或设置环境变量 OPENCLAW_HOME 指向 .openclaw 目录)",
+  PAIR_EXCHANGE_REQUEST_FAILED:
+    "配对请求发送失败(无法连接配对服务,请检查网络、DNS 或代理)",
+  PAIR_EXCHANGE_FAILED:
+    "配对兑换被拒绝(配对码无效、已过期或已被使用;请向签发服务获取新配对码,并在 10 分钟内尽快完成配对)",
+  PAIR_CHANNEL_CONFIG_INVALID:
+    "配对返回的频道配置无效(缺少 mqttUrl 或 mqttTopic)",
+};
+
 export function formatCliErrorPayload(error: unknown): {
   ok: false;
   error: Record<string, unknown>;
@@ -78,11 +92,17 @@ export function formatCliErrorPayload(error: unknown): {
       : {};
   const code =
     dataObject.code ?? (error as { code?: unknown } | null | undefined)?.code;
+  const message = error instanceof Error ? error.message : String(error);
+  // Fall back to the English message when no Chinese translation exists for
+  // the code, so both fields are always present.
+  const messageZh =
+    (typeof code === "string" && ERROR_MESSAGES_ZH[code]) || message;
 
   return {
     ok: false,
     error: {
-      message: error instanceof Error ? error.message : String(error),
+      message,
+      messageZh,
       ...dataObject,
       ...(code === undefined ? {} : { code }),
     },
@@ -117,6 +137,15 @@ const WebSocketChannel: any = {
     },
   },
 
+  // 让配对写入的 channels.rol-websocket-channel 变更被判为 hot：
+  // OpenClaw 只热重载本 channel（进程内 stop→start，加载新 MQTT 连接），
+  // 不整机重启、不等 health-monitor。配置写完即在 gateway 进程内生效。
+  // (plugins.entries.rol-websocket-channel.* 已由 OpenClaw 内置的
+  //  channel-plugin-state 规则自动判为 hot+restart-channel，无需在此声明。)
+  reload: {
+    configPrefixes: ["channels.rol-websocket-channel"],
+  },
+
   configSchema: {
     schema: {
       type: "object",
@@ -388,7 +417,7 @@ const WebSocketChannel: any = {
 
       const text = typeof params.message === "string" ? params.message
         : typeof params.text === "string" ? params.text
-        : "";
+          : "";
 
       const conn = ConnectionManager.getGlobalConnection();
       if (!conn || !conn.ws || !conn.ws.connected) {
@@ -599,6 +628,20 @@ async function handleIncomingMessage(
       return;
     }
 
+    // 收到 sender 消息时，先回复一个确认
+    publishCustomMessageResponse({
+      type: "receiver",
+      trace_id: traceId,
+      source: "system",
+      timestamp: Date.now(),
+      success: true,
+      data: {
+        ok: true,
+        status: "received",
+        message: "已收到消息"
+      }
+    }, innerData, mqttTopic);
+
     // 构造标准消息格式
     const attachments = (innerData.attachments || []).map((att: any) => ({
       url: att.url,
@@ -689,9 +732,9 @@ async function handleIncomingMessage(
         let targetTopic = mqttTopic;
         const sourceType = innerData?.source_type;
         if (targetTopic.endsWith("#")) {
-          const replacement = sourceType === "device" ? "device" : "bot";
-          targetTopic = targetTopic.slice(0, -1) + replacement;
+          targetTopic = targetTopic.slice(0, -1) + 'app';
         }
+        targetTopic = targetTopic.replace('device', 'app').replace('bot', 'app');
 
         conn.ws.publish(targetTopic, JSON.stringify(replyMessage));
       },
@@ -867,9 +910,9 @@ function publishCustomMessageResponse(response: any, innerData: any, mqttTopic:
     let targetTopic = mqttTopic;
     const sourceType = innerData?.source_type;
     if (targetTopic.endsWith("#")) {
-      const replacement = sourceType === "device" ? "device" : "bot";
-      targetTopic = targetTopic.slice(0, -1) + replacement;
+      targetTopic = targetTopic.slice(0, -1) + 'app';
     }
+    targetTopic = targetTopic.replace('device', 'app').replace('bot', 'app');
 
     conn.ws.publish(targetTopic, JSON.stringify(response));
   }
@@ -997,7 +1040,11 @@ function registerAdminBridgeCli(api: OpenClawPluginApi) {
               );
             } catch (error) {
               process.exitCode = 1;
-              process.stderr.write(
+              // Emit the structured error on stdout (same channel as the
+              // success payload) so callers that only capture stdout still
+              // receive the full diagnostic — message, code, status,
+              // serviceMessage — instead of just exit code 1.
+              process.stdout.write(
                 JSON.stringify(formatCliErrorPayload(error), null, 2) + "\n",
               );
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rol-websocket-channel",
-  "version": "1.7.3",
+  "version": "1.7.5",
   "description": "Unified OpenClaw plugin: MQTT Channel + Admin Bridge for remote management",
   "license": "MIT",
   "author": "nixgnehc",

package/src/admin/lib/paths.ts

@@ -13,45 +13,45 @@ export function getProjectRoot(): string {
     root = path.dirname(root);
   }
 
-  console.log('[paths] __dirname:', __dirname);
-  console.log('[paths] getProjectRoot:', root);
+  console.error('[paths] __dirname:', __dirname);
+  console.error('[paths] getProjectRoot:', root);
   return root;
 }
 
 export function getOpenClawRoot(): string {
   if (process.env.OPENCLAW_HOME) {
-    console.log('[paths] getOpenClawRoot from env:', process.env.OPENCLAW_HOME);
+    console.error('[paths] getOpenClawRoot from env:', process.env.OPENCLAW_HOME);
     return path.resolve(process.env.OPENCLAW_HOME);
   }
 
   const projectRoot = getProjectRoot();
   const configuredRoot = findNearestOpenClawConfigRoot(projectRoot);
   if (configuredRoot) {
-    console.log('[paths] getOpenClawRoot from discovered openclaw.json:', configuredRoot);
+    console.error('[paths] getOpenClawRoot from discovered openclaw.json:', configuredRoot);
     return configuredRoot;
   }
 
   const openclawDir = findAncestorNamed(projectRoot, '.openclaw');
   if (openclawDir) {
-    console.log('[paths] getOpenClawRoot from .openclaw ancestor:', openclawDir);
+    console.error('[paths] getOpenClawRoot from .openclaw ancestor:', openclawDir);
     return openclawDir;
   }
 
   const parentDir = path.dirname(projectRoot);
   const parentName = path.basename(parentDir);
 
-  console.log('[paths] projectRoot:', projectRoot);
-  console.log('[paths] parentDir:', parentDir);
-  console.log('[paths] parentName:', parentName);
+  console.error('[paths] projectRoot:', projectRoot);
+  console.error('[paths] parentDir:', parentDir);
+  console.error('[paths] parentName:', parentName);
 
   if (parentName === 'extensions') {
     const openclawRoot = path.dirname(parentDir);
-    console.log('[paths] getOpenClawRoot (extensions):', openclawRoot);
+    console.error('[paths] getOpenClawRoot (extensions):', openclawRoot);
     return openclawRoot;
   }
 
   const fallbackRoot = path.resolve(projectRoot, '..');
-  console.log('[paths] getOpenClawRoot (fallback):', fallbackRoot);
+  console.error('[paths] getOpenClawRoot (fallback):', fallbackRoot);
   return fallbackRoot;
 }
 

package/src/admin/methods/pairing.ts

@@ -1,18 +1,12 @@
-import { exec, execFile } from 'node:child_process';
 import path from 'node:path';
-import { promisify } from 'node:util';
 
 import { pathExists, readJsonFile, writeJsonFile } from '../lib/fs.js';
 import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.js';
 import type { JsonValue, MethodContext } from '../types.js';
 
-const execFileAsync = promisify(execFile);
-const execAsync = promisify(exec);
-
 const DEFAULT_PLUGIN_ID = 'rol-websocket-channel';
 const DEFAULT_PRODUCTION_BASE_URL = 'https://api.deotaland.ai';
 const PAIR_ENDPOINT_PATH = '/api-core-bot/front/agent/agent/key/query';
-const GATEWAY_SERVICE = 'openclaw-gateway.service';
 
 interface PairingCommandOptions {
   key: string;
@@ -73,7 +67,6 @@ export async function pairWithKey(
   const payload = await exchangePairKey(key, endpoint, options.auth, existingMqttUrl);
   applyPairingConfig(config, key, payload);
   await writeJsonFile(configPath, config);
-  const restart = await restartGateway(context.projectRoot);
 
   return {
     ok: true,
@@ -87,7 +80,18 @@ export async function pairWithKey(
       `channels.${payload.pluginId}`
     ],
     channel: payload.channel,
-    restart
+    // No gateway restart is dispatched here on purpose. Writing openclaw.json is
+    // enough: OpenClaw's config watcher detects the `channels` change, plans a
+    // gateway restart, and defers it until in-flight operations/replies/embedded
+    // runs drain before restarting with the new config. Spawning our own
+    // `openclaw gateway restart` would restart immediately and jump ahead of that
+    // deferral, killing the gateway mid-operation (the original pair-hang bug).
+    reload: {
+      dispatched: false,
+      handledBy: 'openclaw-config-watcher',
+      mode: 'deferred-until-idle',
+      note: 'OpenClaw restarts the gateway automatically after the config write.'
+    }
   };
 }
 
@@ -114,11 +118,24 @@ async function exchangePairKey(
     headers.Authorization = auth;
   }
 
-  const response = await fetch(endpoint, {
-    method: 'POST',
-    headers,
-    body: JSON.stringify({ key })
-  });
+  let response: Response;
+  try {
+    response = await fetch(endpoint, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({ key })
+    });
+  } catch (error) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.internalError,
+      `pair exchange request failed: ${error instanceof Error ? error.message : String(error)}`,
+      {
+        code: 'PAIR_EXCHANGE_REQUEST_FAILED',
+        endpoint,
+        cause: describeErrorCause(error)
+      }
+    );
+  }
 
   const rawText = await response.text();
   const payload = tryParseJson(rawText);
@@ -135,9 +152,31 @@ async function exchangePairKey(
     );
   }
 
+  ensurePairExchangeSucceeded(payload, endpoint, response.status);
+
   return normalizePairingPayload(payload, endpoint, existingMqttUrl);
 }
 
+function ensurePairExchangeSucceeded(raw: unknown, endpoint: string, status: number): void {
+  if (!isRecord(raw) || raw.success !== false) {
+    return;
+  }
+
+  const serviceMessage = pickString(raw.message) ?? pickString(raw.msg);
+  throw new JsonRpcException(
+    JSON_RPC_ERRORS.internalError,
+    `pair exchange failed${serviceMessage ? `: ${serviceMessage}` : ''}`,
+    {
+      code: 'PAIR_EXCHANGE_FAILED',
+      endpoint,
+      status,
+      serviceCode: raw.code,
+      success: false,
+      ...(serviceMessage ? { serviceMessage } : {})
+    }
+  );
+}
+
 function normalizePairingPayload(
   raw: unknown,
   endpoint: string,
@@ -364,59 +403,6 @@ function resolveExistingMqttUrl(config: OpenClawConfig): string | null {
   return pickString(channelConfig.mqttUrl);
 }
 
-async function restartGateway(cwd: string): Promise<JsonValue> {
-  const attempts: JsonValue[] = [];
-
-  try {
-    const { stdout, stderr } = await execAsync('openclaw gateway restart', { cwd });
-    return {
-      attempted: true,
-      success: true,
-      command: 'openclaw gateway restart',
-      stdout: stdout.trim(),
-      stderr: stderr.trim()
-    };
-  } catch (error: any) {
-    attempts.push(formatRestartAttempt('openclaw gateway restart', error));
-  }
-
-  if (process.platform === 'win32') {
-    return {
-      attempted: true,
-      success: false,
-      message: 'openclaw gateway restart failed',
-      attempts
-    };
-  }
-
-  try {
-    await execFileAsync('systemctl', ['--user', 'restart', GATEWAY_SERVICE], { cwd });
-    return {
-      attempted: true,
-      success: true,
-      command: `systemctl --user restart ${GATEWAY_SERVICE}`,
-      attempts
-    };
-  } catch (error: any) {
-    attempts.push(formatRestartAttempt(`systemctl --user restart ${GATEWAY_SERVICE}`, error));
-    return {
-      attempted: true,
-      success: false,
-      message: 'gateway restart failed',
-      attempts
-    };
-  }
-}
-
-function formatRestartAttempt(command: string, error: any): JsonValue {
-  return {
-    command,
-    message: error instanceof Error ? error.message : String(error),
-    stdout: typeof error?.stdout === 'string' ? error.stdout.trim() : '',
-    stderr: typeof error?.stderr === 'string' ? error.stderr.trim() : ''
-  };
-}
-
 function normalizeGroupPolicy(value: string): 'pairing' | 'allowlist' | 'open' | 'disabled' {
   if (value === 'pairing' || value === 'allowlist' || value === 'open' || value === 'disabled') {
     return value;
@@ -448,6 +434,33 @@ function isRecord(value: unknown): value is Record<string, any> {
   return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
 
+function describeErrorCause(error: unknown): Record<string, unknown> {
+  const detail: Record<string, unknown> = {};
+  if (error instanceof Error) {
+    detail.name = error.name;
+    detail.message = error.message;
+  } else {
+    detail.message = String(error);
+  }
+
+  const cause = (error as { cause?: unknown } | null | undefined)?.cause;
+  if (isRecord(cause)) {
+    const causeDetail: Record<string, unknown> = {};
+    for (const key of ['name', 'message', 'code', 'errno', 'syscall', 'hostname', 'address', 'port']) {
+      const value = cause[key];
+      if (['string', 'number', 'boolean'].includes(typeof value)) {
+        causeDetail[key] = value;
+      }
+    }
+
+    if (Object.keys(causeDetail).length > 0) {
+      detail.cause = causeDetail;
+    }
+  }
+
+  return detail;
+}
+
 function throwPairingError(code: string, message: string, debug?: PairingPayloadDebug): never {
   throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, message, {
     code,

package/src/admin/methods/sessions-extended.ts

@@ -26,9 +26,10 @@ export const getSession: MethodHandler = async (
     : undefined;
   const sessionId = typeof objectParams.sessionId === 'string' ? objectParams.sessionId : null;
   const requestedLimit = typeof objectParams.limit === 'number' ? objectParams.limit : MAX_SESSION_MESSAGES;
-  const requestedOffset = typeof objectParams.offset === 'number' ? objectParams.offset : 0;
+  const beforeId = typeof objectParams.beforeId === 'string' && objectParams.beforeId.trim()
+    ? objectParams.beforeId.trim()
+    : undefined;
   const limit = normalizePageSize(requestedLimit, MAX_SESSION_MESSAGES);
-  const offset = normalizeOffset(requestedOffset);
 
   if (!sessionId) {
     throw new JsonRpcException(
@@ -52,7 +53,7 @@ export const getSession: MethodHandler = async (
     'sessions',
     `${session.sessionId ?? sessionId}.jsonl`
   );
-  const messages = await readSessionMessages(sessionFile, limit, offset);
+  const messages = await readSessionMessages(sessionFile, limit, beforeId);
 
   return {
     agentId: session.agentId,
@@ -69,7 +70,8 @@ export const getSession: MethodHandler = async (
     messages: {
       total: messages.total,
       limit,
-      offset,
+      hasMore: messages.hasMore,
+      nextBeforeId: messages.nextBeforeId,
       items: messages.items
     }
   };
@@ -203,21 +205,13 @@ function normalizePageSize(value: number, max: number): number {
   return Math.min(normalized, max);
 }
 
-function normalizeOffset(value: number): number {
-  if (!Number.isFinite(value)) {
-    return 0;
-  }
-
-  return Math.max(0, Math.floor(value));
-}
-
 async function readSessionMessages(
   filePath: string,
   limit: number,
-  offset: number
-): Promise<{ total: number; items: SessionMessage[] }> {
+  beforeId?: string
+): Promise<{ total: number; hasMore: boolean; nextBeforeId: string | null; items: SessionMessage[] }> {
   if (!(await pathExists(filePath))) {
-    return { total: 0, items: [] };
+    return { total: 0, hasMore: false, nextBeforeId: null, items: [] };
   }
 
   const messages: SessionMessage[] = [];
@@ -239,9 +233,24 @@ async function readSessionMessages(
     }
   }
 
+  const endExclusive = beforeId ? messages.findIndex((message) => message.id === beforeId) : messages.length;
+  if (endExclusive < 0) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.invalidParams,
+      `beforeId not found: ${beforeId}`
+    );
+  }
+
+  const start = Math.max(0, endExclusive - limit);
+  const items = messages.slice(start, endExclusive);
+  const hasMore = start > 0;
+  const firstItemId = typeof items[0]?.id === 'string' ? items[0].id : null;
+
   return {
     total: messages.length,
-    items: messages.slice(offset, offset + limit)
+    hasMore,
+    nextBeforeId: hasMore ? firstItemId : null,
+    items
   };
 }
 

package/src/admin/methods/system.ts

@@ -11,6 +11,7 @@ const execFileAsync = promisify(execFile);
 const UPDATE_COMMAND_TIMEOUT_MS = 10 * 60 * 1000;
 const UPDATE_COMMAND_MAX_BUFFER = 10 * 1024 * 1024;
 const CHANNEL_FALLBACK_VERSION = '1.5.9';
+const MIN_OPENCLAW_PLUGIN_UPDATE_VERSION = '2026.5.6';
 
 export const ping: MethodHandler = async (): Promise<JsonValue> => {
   return {
@@ -81,6 +82,19 @@ export const doctorFix: MethodHandler = async (_params, context: MethodContext):
 };
 
 export const pluginSelfUpdate: MethodHandler = async (_params, context: MethodContext): Promise<JsonValue> => {
+  const versionCheck = await checkOpenClawVersionForPluginUpdate(context);
+  if (!versionCheck.supported) {
+    return {
+      ok: false,
+      action: 'pluginSelfUpdate',
+      plugin: 'rol-websocket-channel',
+      skipped: true,
+      reason: versionCheck.reason,
+      message: versionCheck.message,
+      restartRecommended: false
+    };
+  }
+
   const result = await runOpenClawCommand(
     ['plugins', 'update', 'rol-websocket-channel'],
     context,
@@ -110,6 +124,61 @@ export const pluginSelfUpdate: MethodHandler = async (_params, context: MethodCo
   };
 };
 
+type PluginUpdateVersionCheck =
+  | {
+      supported: true;
+      currentVersion: string;
+      output: string;
+    }
+  | {
+      supported: false;
+      reason: string;
+      message: string;
+      currentVersion: string | null;
+      output: string;
+    };
+
+async function checkOpenClawVersionForPluginUpdate(context: MethodContext): Promise<PluginUpdateVersionCheck> {
+  try {
+    const result = await runOpenClawCommand(['--version'], context, 'pluginSelfUpdate.versionCheck');
+    const output = `${result.stdout}\n${result.stderr}`.trim();
+    const currentVersion = extractOpenClawVersion(output);
+    if (!currentVersion) {
+      return {
+        supported: false,
+        reason: 'openclaw-version-unreadable',
+        message: `Unable to detect OpenClaw version. Please install or upgrade OpenClaw to ${MIN_OPENCLAW_PLUGIN_UPDATE_VERSION} or newer before updating rol-websocket-channel.`,
+        currentVersion: null,
+        output
+      };
+    }
+
+    if (!isOpenClawVersionAtLeast(currentVersion, MIN_OPENCLAW_PLUGIN_UPDATE_VERSION)) {
+      return {
+        supported: false,
+        reason: 'openclaw-version-too-old',
+        message: `OpenClaw ${currentVersion} is too old for rol-websocket-channel self update. Please install or upgrade OpenClaw to ${MIN_OPENCLAW_PLUGIN_UPDATE_VERSION} or newer.`,
+        currentVersion,
+        output
+      };
+    }
+
+    return {
+      supported: true,
+      currentVersion,
+      output
+    };
+  } catch (error) {
+    return {
+      supported: false,
+      reason: 'openclaw-version-check-failed',
+      message: `Unable to check OpenClaw version. Please install or upgrade OpenClaw to ${MIN_OPENCLAW_PLUGIN_UPDATE_VERSION} or newer before updating rol-websocket-channel.`,
+      currentVersion: null,
+      output: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
 export const currentVersion: MethodHandler = async (_params, context: MethodContext): Promise<JsonValue> => {
   const [channelPackage, registryInfo] = await Promise.all([
     readJsonFile<{ name?: string; version?: string }>(path.join(context.projectRoot, 'package.json')),
@@ -140,6 +209,34 @@ export const currentVersion: MethodHandler = async (_params, context: MethodCont
 };
 
 export const logs: MethodHandler = async (params: any, context: MethodContext): Promise<JsonValue> => {
+  const limit = 10;
+  const maxBytes = normalizePositiveInteger(params?.maxBytes, 250000);
+
+  try {
+    const result = await runOpenClawCommand(
+      ['logs', '--json', '--limit', String(limit), '--max-bytes', String(maxBytes)],
+      context,
+      'logs'
+    );
+    return {
+      ok: true,
+      source: 'openclaw logs',
+      nextOffset: null,
+      lines: parseOpenClawLogOutput(result.stdout).slice(-limit).reverse()
+    };
+  } catch (officialError) {
+    console.error(
+      `[system] openclaw logs failed, falling back to local file scan: ${officialError instanceof Error ? officialError.message : String(officialError)}`
+    );
+    return await readLocalLogFiles(context, limit, maxBytes);
+  }
+};
+
+async function readLocalLogFiles(
+  context: MethodContext,
+  limit: number,
+  maxBytes: number
+): Promise<JsonValue> {
   try {
     // 根据实际情况可能需要调整，这里默认尝试 project root 或 user home 下的 .openclaw/logs
     // 很多时候全局日志位于 ~/.openclaw/logs/gateway.log 或工程目录下的 .openclaw 文件夹中
@@ -201,8 +298,6 @@ export const logs: MethodHandler = async (params: any, context: MethodContext):
       return { ok: false, error: `No .log files found in directory: ${logDir}` };
     }
 
-    const limit = 10;
-    const maxBytes = params?.maxBytes ?? 250000;
     let offset: number | undefined = undefined;
 
     // 获取所有候选日志的详细信息并排序（对应 ls -t）
@@ -267,7 +362,34 @@ export const logs: MethodHandler = async (params: any, context: MethodContext):
       error: error instanceof Error ? error.message : String(error)
     };
   }
-};
+}
+
+function parseOpenClawLogOutput(output: string): JsonValue[] {
+  return output
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+    .map((line) => {
+      try {
+        return JSON.parse(line) as JsonValue;
+      } catch {
+        return line;
+      }
+    })
+    .filter((entry) => !(isJsonObject(entry) && entry.type === 'meta'));
+}
+
+function normalizePositiveInteger(value: unknown, fallback: number): number {
+  if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) {
+    return fallback;
+  }
+
+  return Math.floor(value);
+}
+
+function isJsonObject(value: JsonValue): value is { [key: string]: JsonValue } {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
 
 async function runOpenClawCommand(
   args: string[],
@@ -432,6 +554,30 @@ function normalizeVersion(value: string | undefined): string {
   return value.trim().replace(/^v/i, '');
 }
 
+function isOpenClawVersionAtLeast(current: string, minimum: string): boolean {
+  const currentVersion = extractOpenClawVersion(current);
+  const minimumVersion = extractOpenClawVersion(minimum);
+  if (!currentVersion || !minimumVersion) {
+    return false;
+  }
+
+  const currentParts = currentVersion.split('.').map(Number);
+  const minimumParts = minimumVersion.split('.').map(Number);
+  for (let i = 0; i < Math.max(currentParts.length, minimumParts.length); i += 1) {
+    const currentPart = currentParts[i] ?? 0;
+    const minimumPart = minimumParts[i] ?? 0;
+    if (currentPart > minimumPart) return true;
+    if (currentPart < minimumPart) return false;
+  }
+
+  return true;
+}
+
+function extractOpenClawVersion(value: string): string | null {
+  const match = value.match(/\b(\d{4}\.\d+\.\d+)\b/);
+  return match ? match[1] : null;
+}
+
 function isPathSourceUpdateSkip(output: string): boolean {
   return /Skipping\s+"?rol-websocket-channel"?\s+\(source:\s*path\)/i.test(output);
 }

package/tsconfig.json

@@ -13,5 +13,5 @@
     "rootDir": "."
   },
   "include": ["index.ts", "src/**/*.ts", "types/**/*.d.ts"],
-  "exclude": ["node_modules", "dist"]
+  "exclude": ["node_modules", "dist", "test", "**/*.test.ts", "**/*.spec.ts"]
 }