rol-websocket-channel 1.6.0 → 1.6.3

package/dist/index.js

@@ -490,7 +490,8 @@ async function handleIncomingMessage(payload, account, cfg, runtime, log, mqttTo
         log?.error(`[rol-websocket-channel] Failed to process message: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
-async function handleCustomMessageType(msgType, innerData, traceId, accountId, mqttTopic) {
+const immediateAckMessageTypes = new Set(["openclawUpdate", "pluginSelfUpdate"]);
+export async function handleCustomMessageType(msgType, innerData, traceId, accountId, mqttTopic) {
     const isSkillInstallFlow = msgType === "skillsInstallFromClawHub" || msgType === "skillsUpdateFromClawHub";
     const response = {
         type: "receiver",
@@ -503,6 +504,19 @@ async function handleCustomMessageType(msgType, innerData, traceId, accountId, m
     }
     const handlerMethod = messageHandler[msgType];
     if (typeof handlerMethod === "function") {
+        if (immediateAckMessageTypes.has(msgType)) {
+            response.success = true;
+            response.data = {
+                ok: true,
+                action: msgType,
+                status: "running",
+                accepted: true,
+                message: `${msgType} started`,
+            };
+            publishCustomMessageResponse(response, innerData, mqttTopic);
+            void runCustomMessageHandler(msgType, handlerMethod, innerData, response, mqttTopic);
+            return;
+        }
         try {
             const methodResult = await handlerMethod.call(messageHandler, innerData);
             // 兼容两种返回格式：
@@ -545,6 +559,41 @@ async function handleCustomMessageType(msgType, innerData, traceId, accountId, m
         response.success = false;
         response.error = `Unknown message type: ${msgType}`;
     }
+    publishCustomMessageResponse(response, innerData, mqttTopic);
+}
+async function runCustomMessageHandler(msgType, handlerMethod, innerData, baseResponse, mqttTopic) {
+    const response = {
+        ...baseResponse,
+        timestamp: Date.now(),
+    };
+    try {
+        const methodResult = await handlerMethod.call(messageHandler, innerData);
+        if (typeof methodResult === "object" &&
+            methodResult !== null &&
+            "ok" in methodResult) {
+            response.success = methodResult.ok;
+            response.data = methodResult.result;
+            if (!methodResult.ok) {
+                response.error = methodResult.error?.message || "Unknown error";
+            }
+            else {
+                delete response.error;
+            }
+        }
+        else {
+            response.success = true;
+            response.data = methodResult;
+            delete response.error;
+        }
+    }
+    catch (handlerErr) {
+        response.success = false;
+        response.data = undefined;
+        response.error = handlerErr.message;
+    }
+    publishCustomMessageResponse(response, innerData, mqttTopic);
+}
+function publishCustomMessageResponse(response, innerData, mqttTopic) {
     const conn = ConnectionManager.getGlobalConnection();
     if (conn && conn.ws && conn.ws.connected) {
         // 根据 source_type 修改 topic 末尾的 #

package/dist/message-handler.js

@@ -6,7 +6,7 @@ import { getContext } from './src/shared/context.js';
 import { wrapAdminCall } from './src/shared/wrapper.js';
 import { getAgents, getConfig, setApiCoreBotConfig } from './src/admin/methods/admin.js';
 import { createAgent, deleteAgent, listAgents, updateAgent } from './src/admin/methods/agents-extended.js';
-import { createArtifactRecord, ensureArtifactUploaded, getArtifactContent, getArtifactPresignedPost, listArtifacts, markArtifactUploaded, refreshArtifacts } from './src/admin/methods/artifacts.js';
+import { createArtifactRecord, ensureArtifactUploaded, findLatestArtifacts, getArtifactContent, getArtifactPresignedPost, listArtifacts, markArtifactUploaded, publishArtifact, refreshArtifacts } from './src/admin/methods/artifacts.js';
 import { addCron, disableCron, enableCron, getCronStatus, listCron, listCronRuns, renameCron, removeCron, rescheduleCron, runCron, setCronContent, updateCronMessage, updateCronSystemEvent } from './src/admin/methods/cron.js';
 import { listSessions } from './src/admin/methods/sessions.js';
 import { getSession, prepareMessage, attachSkill } from './src/admin/methods/sessions-extended.js';
@@ -400,6 +400,12 @@ export class MessageHandler {
             return await refreshArtifacts(data, context);
         });
     }
+    async artifactsFindLatest(data) {
+        return wrapAdminCall(async () => {
+            const context = getContext();
+            return await findLatestArtifacts(data, context);
+        });
+    }
     async artifactsGetContent(data) {
         return wrapAdminCall(async () => {
             const context = getContext();
@@ -412,6 +418,12 @@ export class MessageHandler {
             return await ensureArtifactUploaded(data, context);
         });
     }
+    async artifactsPublish(data) {
+        return wrapAdminCall(async () => {
+            const context = getContext();
+            return await publishArtifact(data, context);
+        });
+    }
     async artifactsGetPresignedPost(data) {
         return wrapAdminCall(async () => {
             const context = getContext();

package/dist/src/admin/methods/admin.js

@@ -2,8 +2,6 @@ import path from 'node:path';
 import { readJsonFile, writeJsonFile } from '../lib/fs.js';
 import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.js';
 const DEFAULT_PLUGIN_ID = 'rol-websocket-channel';
-const DEFAULT_API_CORE_BOT_BASE_URL = 'http://192.168.1.23:9092';
-const DEFAULT_API_CORE_BOT_AUTH_TOKEN = '123';
 export const getAgents = async (_params, context) => {
     const configPath = path.join(context.openclawRoot, 'openclaw.json');
     const config = await readJsonFile(configPath);
@@ -36,10 +34,10 @@ export const setApiCoreBotConfig = async (params, context) => {
     const objectParams = isObject(params) ? params : {};
     const baseUrl = typeof objectParams.baseUrl === 'string'
         ? objectParams.baseUrl.trim().replace(/\/+$/, '')
-        : DEFAULT_API_CORE_BOT_BASE_URL;
+        : '';
     const authToken = typeof objectParams.authToken === 'string' && objectParams.authToken.trim()
         ? objectParams.authToken.trim()
-        : DEFAULT_API_CORE_BOT_AUTH_TOKEN;
+        : null;
     if (!baseUrl) {
         throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'apiCoreBot.baseUrl is required');
     }

package/dist/src/admin/methods/admin.test.js

@@ -43,15 +43,12 @@ test('setApiCoreBotConfig writes apiCoreBot endpoint without changing pairing or
     assert.equal(savedConfig.plugins.entries['rol-websocket-channel'].config.pairing.pairingKeyLast4, '7a46');
     assert.equal(savedConfig.channels['rol-websocket-channel'].config.mqttUrl, 'ws://mqtt.example.test:8083/mqtt');
 });
-test('setApiCoreBotConfig uses default apiCoreBot values when omitted', async () => {
+test('setApiCoreBotConfig rejects missing baseUrl instead of writing defaults', async () => {
     const context = await createMethodContext();
-    await fs.writeFile(path.join(context.openclawRoot, 'openclaw.json'), '{}');
-    const result = await setApiCoreBotConfig({}, context);
-    const savedConfig = JSON.parse(await fs.readFile(path.join(context.openclawRoot, 'openclaw.json'), 'utf8'));
-    assert.equal(result.apiCoreBot.baseUrl, 'http://192.168.1.23:9092');
-    assert.equal(result.apiCoreBot.authToken, '********');
-    assert.equal(savedConfig.plugins.entries['rol-websocket-channel'].config.apiCoreBot.baseUrl, 'http://192.168.1.23:9092');
-    assert.equal(savedConfig.plugins.entries['rol-websocket-channel'].config.apiCoreBot.authToken, '123');
+    const configPath = path.join(context.openclawRoot, 'openclaw.json');
+    await fs.writeFile(configPath, '{}');
+    await assert.rejects(() => setApiCoreBotConfig({}, context), /apiCoreBot\.baseUrl is required/);
+    assert.equal(await fs.readFile(configPath, 'utf8'), '{}');
 });
 async function createMethodContext() {
     const projectRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'api-core-bot-config-test-'));

package/dist/src/admin/methods/models-extended.js

@@ -32,6 +32,16 @@ export const updateModels = async (params, context) => {
     const changes = [];
     // 更新 primary model
     if (primaryModel) {
+        const inferredProvider = inferProviderFromPrimaryModel(primaryModel);
+        if (!inferredProvider) {
+            throwModelError('MODEL_PRIMARY_INVALID', 'primaryModel must be in provider/model format');
+        }
+        if (modelProvider && modelProvider !== inferredProvider) {
+            throwModelError('MODEL_PROVIDER_MISMATCH', 'modelProvider does not match primaryModel');
+        }
+        if (!isAllowedModel(config, primaryModel)) {
+            throwModelError('MODEL_NOT_ALLOWED', 'model is not in allowed model options');
+        }
         if (!config.agents)
             config.agents = {};
         if (!config.agents.defaults)
@@ -39,10 +49,6 @@ export const updateModels = async (params, context) => {
         if (!config.agents.defaults.model)
             config.agents.defaults.model = {};
         config.agents.defaults.model.primary = primaryModel;
-        const inferredProvider = inferProviderFromPrimaryModel(primaryModel);
-        if (modelProvider && modelProvider !== inferredProvider) {
-            throwModelError('MODEL_PROVIDER_MISMATCH', 'modelProvider does not match primaryModel');
-        }
         updated = true;
         changes.push(`Updated primary model to: ${primaryModel}`);
     }

package/dist/src/admin/methods/system.js

@@ -8,7 +8,7 @@ const execAsync = promisify(exec);
 const execFileAsync = promisify(execFile);
 const UPDATE_COMMAND_TIMEOUT_MS = 10 * 60 * 1000;
 const UPDATE_COMMAND_MAX_BUFFER = 10 * 1024 * 1024;
-const OPENCLAW_UPDATE_TARGET_PACKAGE = '@openclaw/core';
+const OPENCLAW_UPDATE_TARGET_PACKAGE = 'openclaw';
 const OPENCLAW_UPDATE_TARGET_VERSION = '2026.5.6';
 const CHANNEL_FALLBACK_VERSION = '1.5.9';
 export const ping = async () => {
@@ -76,8 +76,7 @@ export const doctorFix = async (_params, context) => {
     }
 };
 export const openclawUpdate = async (_params, context) => {
-    const packageSpec = `${OPENCLAW_UPDATE_TARGET_PACKAGE}@${OPENCLAW_UPDATE_TARGET_VERSION}`;
-    const installResult = await runSystemCommand(process.env.NPM_BIN || 'npm', ['install', '-g', packageSpec], context.openclawRoot, context, 'openclawUpdate.installCore');
+    const updateResult = await runOpenClawCommand(['update', '--tag', OPENCLAW_UPDATE_TARGET_VERSION], context, 'openclawUpdate.update');
     const versionResult = await runOpenClawCommand(['--version'], context, 'openclawUpdate.version');
     const doctorResult = await runOpenClawCommand(['doctor', '--deep'], context, 'openclawUpdate.doctorDeep');
     return {
@@ -87,7 +86,7 @@ export const openclawUpdate = async (_params, context) => {
         targetVersion: OPENCLAW_UPDATE_TARGET_VERSION,
         restartRecommended: true,
         steps: [
-            buildCommandStep('installCore', installResult),
+            buildCommandStep('update', updateResult),
             buildCommandStep('version', versionResult),
             buildCommandStep('doctorDeep', doctorResult)
         ]

package/index.ts

@@ -625,7 +625,9 @@ async function handleIncomingMessage(
   }
 }
 
-async function handleCustomMessageType(
+const immediateAckMessageTypes = new Set(["openclawUpdate", "pluginSelfUpdate"]);
+
+export async function handleCustomMessageType(
   msgType: string,
   innerData: any,
   traceId: string,
@@ -648,6 +650,21 @@ async function handleCustomMessageType(
 
   const handlerMethod = (messageHandler as any)[msgType];
   if (typeof handlerMethod === "function") {
+    if (immediateAckMessageTypes.has(msgType)) {
+      response.success = true;
+      response.data = {
+        ok: true,
+        action: msgType,
+        status: "running",
+        accepted: true,
+        message: `${msgType} started`,
+      };
+      publishCustomMessageResponse(response, innerData, mqttTopic);
+
+      void runCustomMessageHandler(msgType, handlerMethod, innerData, response, mqttTopic);
+      return;
+    }
+
     try {
       const methodResult = await handlerMethod.call(messageHandler, innerData);
 
@@ -698,6 +715,51 @@ async function handleCustomMessageType(
     response.error = `Unknown message type: ${msgType}`;
   }
 
+  publishCustomMessageResponse(response, innerData, mqttTopic);
+}
+
+async function runCustomMessageHandler(
+  msgType: string,
+  handlerMethod: Function,
+  innerData: any,
+  baseResponse: any,
+  mqttTopic: string,
+): Promise<void> {
+  const response = {
+    ...baseResponse,
+    timestamp: Date.now(),
+  };
+
+  try {
+    const methodResult = await handlerMethod.call(messageHandler, innerData);
+
+    if (
+      typeof methodResult === "object" &&
+      methodResult !== null &&
+      "ok" in methodResult
+    ) {
+      response.success = methodResult.ok;
+      response.data = methodResult.result;
+      if (!methodResult.ok) {
+        response.error = methodResult.error?.message || "Unknown error";
+      } else {
+        delete response.error;
+      }
+    } else {
+      response.success = true;
+      response.data = methodResult;
+      delete response.error;
+    }
+  } catch (handlerErr: any) {
+    response.success = false;
+    response.data = undefined;
+    response.error = handlerErr.message;
+  }
+
+  publishCustomMessageResponse(response, innerData, mqttTopic);
+}
+
+function publishCustomMessageResponse(response: any, innerData: any, mqttTopic: string): void {
   const conn = ConnectionManager.getGlobalConnection();
   if (conn && conn.ws && conn.ws.connected) {
     // 根据 source_type 修改 topic 末尾的 #

package/message-handler.ts

@@ -10,10 +10,12 @@ import { createAgent, deleteAgent, listAgents, updateAgent } from './src/admin/m
 import {
   createArtifactRecord,
   ensureArtifactUploaded,
+  findLatestArtifacts,
   getArtifactContent,
   getArtifactPresignedPost,
   listArtifacts,
   markArtifactUploaded,
+  publishArtifact,
   refreshArtifacts
 } from './src/admin/methods/artifacts.js';
 import {
@@ -493,6 +495,13 @@ export class MessageHandler {
     });
   }
 
+  async artifactsFindLatest(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await findLatestArtifacts(data, context);
+    });
+  }
+
   async artifactsGetContent(data: any): Promise<any> {
     return wrapAdminCall(async () => {
       const context = getContext();
@@ -507,6 +516,13 @@ export class MessageHandler {
     });
   }
 
+  async artifactsPublish(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await publishArtifact(data, context);
+    });
+  }
+
   async artifactsGetPresignedPost(data: any): Promise<any> {
     return wrapAdminCall(async () => {
       const context = getContext();

package/package.json

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

package/src/admin/methods/admin.test.ts

@@ -67,28 +67,16 @@ test('setApiCoreBotConfig writes apiCoreBot endpoint without changing pairing or
   );
 });
 
-test('setApiCoreBotConfig uses default apiCoreBot values when omitted', async () => {
+test('setApiCoreBotConfig rejects missing baseUrl instead of writing defaults', async () => {
   const context = await createMethodContext();
-  await fs.writeFile(path.join(context.openclawRoot, 'openclaw.json'), '{}');
-
-  const result = await setApiCoreBotConfig({}, context) as {
-    apiCoreBot: {
-      baseUrl: string;
-      authToken: string;
-    };
-  };
-  const savedConfig = JSON.parse(await fs.readFile(path.join(context.openclawRoot, 'openclaw.json'), 'utf8'));
+  const configPath = path.join(context.openclawRoot, 'openclaw.json');
+  await fs.writeFile(configPath, '{}');
 
-  assert.equal(result.apiCoreBot.baseUrl, 'http://192.168.1.23:9092');
-  assert.equal(result.apiCoreBot.authToken, '********');
-  assert.equal(
-    savedConfig.plugins.entries['rol-websocket-channel'].config.apiCoreBot.baseUrl,
-    'http://192.168.1.23:9092'
-  );
-  assert.equal(
-    savedConfig.plugins.entries['rol-websocket-channel'].config.apiCoreBot.authToken,
-    '123'
+  await assert.rejects(
+    () => setApiCoreBotConfig({}, context),
+    /apiCoreBot\.baseUrl is required/
   );
+  assert.equal(await fs.readFile(configPath, 'utf8'), '{}');
 });
 
 async function createMethodContext(): Promise<MethodContext> {

package/src/admin/methods/admin.ts

@@ -5,8 +5,6 @@ import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.js';
 import type { JsonValue, MethodHandler } from '../types.js';
 
 const DEFAULT_PLUGIN_ID = 'rol-websocket-channel';
-const DEFAULT_API_CORE_BOT_BASE_URL = 'http://192.168.1.23:9092';
-const DEFAULT_API_CORE_BOT_AUTH_TOKEN = '123';
 
 interface OpenClawConfig {
   agents?: {
@@ -63,10 +61,10 @@ export const setApiCoreBotConfig: MethodHandler = async (params, context): Promi
   const objectParams = isObject(params) ? params : {};
   const baseUrl = typeof objectParams.baseUrl === 'string'
     ? objectParams.baseUrl.trim().replace(/\/+$/, '')
-    : DEFAULT_API_CORE_BOT_BASE_URL;
+    : '';
   const authToken = typeof objectParams.authToken === 'string' && objectParams.authToken.trim()
     ? objectParams.authToken.trim()
-    : DEFAULT_API_CORE_BOT_AUTH_TOKEN;
+    : null;
 
   if (!baseUrl) {
     throw new JsonRpcException(

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

@@ -62,18 +62,33 @@ export const updateModels: MethodHandler = async (
 
   // 更新 primary model
   if (primaryModel) {
-    if (!config.agents) config.agents = {};
-    if (!config.agents.defaults) config.agents.defaults = {};
-    if (!config.agents.defaults.model) config.agents.defaults.model = {};
-    
-    config.agents.defaults.model.primary = primaryModel;
     const inferredProvider = inferProviderFromPrimaryModel(primaryModel);
+    if (!inferredProvider) {
+      throwModelError(
+        'MODEL_PRIMARY_INVALID',
+        'primaryModel must be in provider/model format'
+      );
+    }
+
     if (modelProvider && modelProvider !== inferredProvider) {
       throwModelError(
         'MODEL_PROVIDER_MISMATCH',
         'modelProvider does not match primaryModel'
       );
     }
+
+    if (!isAllowedModel(config, primaryModel)) {
+      throwModelError(
+        'MODEL_NOT_ALLOWED',
+        'model is not in allowed model options'
+      );
+    }
+
+    if (!config.agents) config.agents = {};
+    if (!config.agents.defaults) config.agents.defaults = {};
+    if (!config.agents.defaults.model) config.agents.defaults.model = {};
+    
+    config.agents.defaults.model.primary = primaryModel;
     updated = true;
     changes.push(`Updated primary model to: ${primaryModel}`);
   }

package/src/admin/methods/system.ts

@@ -10,7 +10,7 @@ const execAsync = promisify(exec);
 const execFileAsync = promisify(execFile);
 const UPDATE_COMMAND_TIMEOUT_MS = 10 * 60 * 1000;
 const UPDATE_COMMAND_MAX_BUFFER = 10 * 1024 * 1024;
-const OPENCLAW_UPDATE_TARGET_PACKAGE = '@openclaw/core';
+const OPENCLAW_UPDATE_TARGET_PACKAGE = 'openclaw';
 const OPENCLAW_UPDATE_TARGET_VERSION = '2026.5.6';
 const CHANNEL_FALLBACK_VERSION = '1.5.9';
 
@@ -83,13 +83,10 @@ export const doctorFix: MethodHandler = async (_params, context: MethodContext):
 };
 
 export const openclawUpdate: MethodHandler = async (_params, context: MethodContext): Promise<JsonValue> => {
-  const packageSpec = `${OPENCLAW_UPDATE_TARGET_PACKAGE}@${OPENCLAW_UPDATE_TARGET_VERSION}`;
-  const installResult = await runSystemCommand(
-    process.env.NPM_BIN || 'npm',
-    ['install', '-g', packageSpec],
-    context.openclawRoot,
+  const updateResult = await runOpenClawCommand(
+    ['update', '--tag', OPENCLAW_UPDATE_TARGET_VERSION],
     context,
-    'openclawUpdate.installCore'
+    'openclawUpdate.update'
   );
   const versionResult = await runOpenClawCommand(['--version'], context, 'openclawUpdate.version');
   const doctorResult = await runOpenClawCommand(['doctor', '--deep'], context, 'openclawUpdate.doctorDeep');
@@ -101,7 +98,7 @@ export const openclawUpdate: MethodHandler = async (_params, context: MethodCont
     targetVersion: OPENCLAW_UPDATE_TARGET_VERSION,
     restartRecommended: true,
     steps: [
-      buildCommandStep('installCore', installResult),
+      buildCommandStep('update', updateResult),
       buildCommandStep('version', versionResult),
       buildCommandStep('doctorDeep', doctorResult)
     ]

package/test/admin/methods/models-extended.test.ts

@@ -0,0 +1,49 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { updateModels } from '../../../src/admin/methods/models-extended.js';
+import { JsonRpcException, JSON_RPC_ERRORS } from '../../../src/admin/jsonrpc.js';
+import type { MethodContext } from '../../../src/admin/types.js';
+
+test('updateModels rejects primaryModel values outside the allowed catalog', async () => {
+  const context = await createMethodContext();
+  await fs.writeFile(path.join(context.openclawRoot, 'openclaw.json'), JSON.stringify({
+    agents: {
+      defaults: {
+        model: {
+          primary: 'openai/gpt-5.4-mini'
+        },
+        models: {
+          'openai/gpt-5.4-mini': {
+            label: 'GPT-5.4 Mini'
+          }
+        }
+      }
+    }
+  }, null, 2));
+
+  await assert.rejects(
+    updateModels({ primaryModel: 'openai/not-allowed' }, context),
+    (error: unknown) => {
+      assert.ok(error instanceof JsonRpcException);
+      assert.equal(error.code, JSON_RPC_ERRORS.invalidParams);
+      assert.equal(error.message, 'model is not in allowed model options');
+      assert.deepEqual(error.data, { code: 'MODEL_NOT_ALLOWED' });
+      return true;
+    }
+  );
+});
+
+async function createMethodContext(): Promise<MethodContext> {
+  const projectRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'models-extended-test-'));
+  const openclawRoot = path.join(projectRoot, '.openclaw');
+  await fs.mkdir(openclawRoot, { recursive: true });
+
+  return {
+    projectRoot,
+    openclawRoot
+  };
+}

package/test/custom-message-update-ack.test.ts

@@ -0,0 +1,77 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { handleCustomMessageType } from '../index.js';
+import { messageHandler } from '../message-handler.js';
+import {
+  _setMqttConnectFn,
+  closeGlobalConnection,
+  createGlobalMqttConnection
+} from '../src/mqtt/connection-manager.js';
+
+test('openclawUpdate publishes an immediate running response before the command finishes', async () => {
+  const published: Array<{ topic: string; message: string }> = [];
+  const originalOpenclawUpdate = (messageHandler as any).openclawUpdate;
+  let finish!: () => void;
+  const commandFinished = new Promise<void>((resolve) => {
+    finish = resolve;
+  });
+
+  const fakeClient = {
+    connected: true,
+    on() {},
+    subscribe() {},
+    end() {},
+    publish(topic: string, message: string) {
+      published.push({ topic, message });
+    }
+  };
+
+  _setMqttConnectFn(() => fakeClient as any);
+  await createGlobalMqttConnection('mqtt://test', 'announcement/user/agent/#', {});
+
+  try {
+    (messageHandler as any).openclawUpdate = async () => {
+      await commandFinished;
+      return { ok: true, result: { ok: true, action: 'openclawUpdate' } };
+    };
+
+    const task = handleCustomMessageType(
+      'openclawUpdate',
+      { source_type: 'device' },
+      'trace-update-001',
+      'default',
+      'announcement/user/agent/#'
+    );
+
+    await new Promise((resolve) => setImmediate(resolve));
+
+    assert.equal(published.length, 1);
+    const first = JSON.parse(published[0]!.message);
+    assert.equal(published[0]!.topic, 'announcement/user/agent/device');
+    assert.equal(first.trace_id, 'trace-update-001');
+    assert.equal(first.success, true);
+    assert.equal(first.data.status, 'running');
+
+    await task;
+    finish();
+    await waitFor(() => published.length === 2);
+
+    assert.equal(published.length, 2);
+    const final = JSON.parse(published[1]!.message);
+    assert.equal(final.trace_id, 'trace-update-001');
+    assert.equal(final.success, true);
+    assert.deepEqual(final.data, { ok: true, action: 'openclawUpdate' });
+  } finally {
+    (messageHandler as any).openclawUpdate = originalOpenclawUpdate;
+    closeGlobalConnection();
+    _setMqttConnectFn(null);
+  }
+});
+
+async function waitFor(predicate: () => boolean): Promise<void> {
+  for (let i = 0; i < 20; i += 1) {
+    if (predicate()) return;
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+}

package/test/message-handler-artifacts.test.ts

@@ -0,0 +1,11 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { MessageHandler } from '../message-handler.js';
+
+test('message handler exposes artifact convenience MQTT methods', () => {
+  const handler = new MessageHandler() as any;
+
+  assert.equal(typeof handler.artifactsFindLatest, 'function');
+  assert.equal(typeof handler.artifactsPublish, 'function');
+});