rol-websocket-channel 1.6.2 → 1.6.4

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');
+});