rol-websocket-channel 1.0.7 → 1.0.9

package/index.ts

@@ -99,11 +99,13 @@ const WebSocketChannel: ChannelPlugin<WebSocketChannelAccount> = {
             authToken: { type: "string" },
           },
         },
+        pairingEndpoint: { type: "string" },
         config: {
           type: "object",
           additionalProperties: false,
           properties: {
             enabled: { type: "boolean" },
+            pairingEndpoint: { type: "string" },
             mqttUrl: { type: "string" },
             mqttTopic: { type: "string" },
             groupPolicy: {
@@ -133,10 +135,18 @@ const WebSocketChannel: ChannelPlugin<WebSocketChannelAccount> = {
         label: "API Core Bot",
         description: "Backend API endpoint and auth token used by the plugin",
       },
+      pairingEndpoint: {
+        label: "Pairing Endpoint",
+        description: "Optional pairing API endpoint or base URL for staging/local environments",
+      },
       config: {
         label: "Configuration",
         description: "MQTT connection configuration",
       },
+      "config.pairingEndpoint": {
+        label: "Pairing Endpoint",
+        description: "Optional pairing API endpoint or base URL for staging/local environments",
+      },
       "config.enabled": {
         label: "Enabled",
         description: "Enable this configuration",

package/message-handler.ts

@@ -7,6 +7,21 @@ import { getContext } from './src/shared/context.js';
 import { wrapAdminCall } from './src/shared/wrapper.js';
 import { getAgents, getConfig } from './src/admin/methods/admin.js';
 import { createAgent, deleteAgent, listAgents, updateAgent } from './src/admin/methods/agents-extended.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';
 import { getModels } from './src/admin/methods/models.js';
@@ -103,6 +118,97 @@ export class MessageHandler {
     });
   }
 
+  async cronList(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await listCron(data, context);
+    });
+  }
+
+  async cronStatus(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await getCronStatus(data, context);
+    });
+  }
+
+  async cronRuns(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await listCronRuns(data, context);
+    });
+  }
+
+  async cronAdd(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await addCron(data, context);
+    });
+  }
+
+  async cronRename(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await renameCron(data, context);
+    });
+  }
+
+  async cronReschedule(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await rescheduleCron(data, context);
+    });
+  }
+
+  async cronSetContent(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await setCronContent(data, context);
+    });
+  }
+
+  async cronUpdateMessage(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await updateCronMessage(data, context);
+    });
+  }
+
+  async cronUpdateSystemEvent(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await updateCronSystemEvent(data, context);
+    });
+  }
+
+  async cronEnable(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await enableCron(data, context);
+    });
+  }
+
+  async cronDisable(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await disableCron(data, context);
+    });
+  }
+
+  async cronRun(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await runCron(data, context);
+    });
+  }
+
+  async cronRemove(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await removeCron(data, context);
+    });
+  }
+
   /**
    * 列出 sessions
    */

package/openclaw.plugin.json

@@ -55,6 +55,9 @@
           }
         }
       },
+      "pairingEndpoint": {
+        "type": "string"
+      },
       "channels": {
         "type": "object",
         "additionalProperties": false,
@@ -99,6 +102,9 @@
                   }
                 }
               },
+              "pairingEndpoint": {
+                "type": "string"
+              },
               "dmPolicy": {
                 "type": "string",
                 "enum": ["pairing", "allowlist", "open", "disabled"]
@@ -116,6 +122,9 @@
                   "enabled": {
                     "type": "boolean"
                   },
+                  "pairingEndpoint": {
+                    "type": "string"
+                  },
                   "mqttUrl": {
                     "type": "string"
                   },
@@ -149,6 +158,10 @@
       "label": "API Core Bot",
       "description": "Backend API endpoint and auth token used by the plugin"
     },
+    "pairingEndpoint": {
+      "label": "Pairing Endpoint",
+      "description": "Optional pairing API endpoint or base URL for staging/local environments"
+    },
     "dmPolicy": {
       "label": "DM Policy",
       "description": "Pairing/allowlist/open policy for direct messages"
@@ -175,6 +188,10 @@
       "label": "API Core Bot",
       "description": "Backend API endpoint and auth token used by the plugin"
     },
+    "channels.rol-websocket-channel.pairingEndpoint": {
+      "label": "Pairing Endpoint",
+      "description": "Optional pairing API endpoint or base URL for staging/local environments"
+    },
     "channels.rol-websocket-channel.dmPolicy": {
       "label": "DM Policy",
       "description": "Pairing/allowlist/open policy for direct messages"
@@ -191,6 +208,10 @@
       "label": "Enabled",
       "description": "Enable this configuration"
     },
+    "channels.rol-websocket-channel.config.pairingEndpoint": {
+      "label": "Pairing Endpoint",
+      "description": "Optional pairing API endpoint or base URL for staging/local environments"
+    },
     "channels.rol-websocket-channel.config.mqttUrl": {
       "label": "MQTT Broker URL",
       "placeholder": "ws://192.168.1.152:8083/mqtt",

package/package.json

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

package/src/admin/methods/cron.ts

@@ -0,0 +1,327 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.js';
+import type { JsonValue, MethodContext, MethodHandler } from '../types.js';
+
+const execFileAsync = promisify(execFile);
+
+type CronSession = 'main' | 'isolated';
+type CronScheduleKey = 'at' | 'every' | 'cron';
+
+export const listCron: MethodHandler = async (_params, context): Promise<JsonValue> => {
+  return await runOpenClawCronCommand(['cron', 'list'], context);
+};
+
+export const getCronStatus: MethodHandler = async (_params, context): Promise<JsonValue> => {
+  return await runOpenClawCronCommand(['cron', 'status'], context);
+};
+
+export const listCronRuns: MethodHandler = async (params, context): Promise<JsonValue> => {
+  const objectParams = expectObject(params);
+  const id = expectString(objectParams.id, 'id');
+  const args = ['cron', 'runs', '--id', id];
+  appendOptionalPositiveInteger(args, '--limit', objectParams.limit, 'limit');
+  return await runOpenClawCronCommand(args, context);
+};
+
+export const addCron: MethodHandler = async (params, context): Promise<JsonValue> => {
+  const objectParams = expectObject(params);
+  const name = expectString(objectParams.name, 'name');
+  const scheduleKey = expectSingleSchedule(objectParams);
+  const scheduleValue = expectString(objectParams[scheduleKey], scheduleKey);
+  const session = expectSession(objectParams.session);
+  const contentKey = expectContentForSession(objectParams, session);
+  const contentValue = expectString(objectParams[contentKey], contentKey);
+
+  const args = [
+    'cron',
+    'add',
+    '--name',
+    name,
+    `--${scheduleKey}`,
+    scheduleValue,
+    '--session',
+    session,
+    `--${toKebabCase(contentKey)}`,
+    contentValue
+  ];
+
+  appendOptionalString(args, '--description', objectParams.description);
+  appendOptionalString(args, '--agent', objectParams.agent);
+  appendOptionalString(args, '--model', objectParams.model);
+  appendOptionalString(args, '--thinking', objectParams.thinking);
+  appendOptionalString(args, '--channel', objectParams.channel);
+  appendOptionalString(args, '--to', objectParams.to);
+  appendOptionalString(args, '--tz', objectParams.tz);
+  appendOptionalPositiveInteger(args, '--timeout', objectParams.timeout, 'timeout');
+  appendOptionalTools(args, objectParams.tools);
+  appendOptionalBooleanFlag(args, '--announce', objectParams.announce);
+  appendOptionalBooleanFlag(args, '--disabled', objectParams.disabled);
+
+  return await runOpenClawCronCommand(args, context);
+};
+
+export const renameCron: MethodHandler = async (params, context): Promise<JsonValue> => {
+  const objectParams = expectObject(params);
+  const id = expectString(objectParams.id, 'id');
+  const args = ['cron', 'edit', id];
+  appendOptionalString(args, '--name', objectParams.name);
+  appendOptionalString(args, '--description', objectParams.description);
+  assertHasPatchArgs(args, 3, "At least one field is required: 'name' or 'description'");
+  return await runOpenClawCronCommand(args, context);
+};
+
+export const rescheduleCron: MethodHandler = async (params, context): Promise<JsonValue> => {
+  const objectParams = expectObject(params);
+  const id = expectString(objectParams.id, 'id');
+  const scheduleKey = expectSingleSchedule(objectParams);
+  const scheduleValue = expectString(objectParams[scheduleKey], scheduleKey);
+  const args = ['cron', 'edit', id, `--${scheduleKey}`, scheduleValue];
+  appendOptionalString(args, '--tz', objectParams.tz);
+  return await runOpenClawCronCommand(args, context);
+};
+
+export const setCronContent: MethodHandler = async (params, context): Promise<JsonValue> => {
+  const objectParams = expectObject(params);
+  const id = expectString(objectParams.id, 'id');
+  const session = expectSession(objectParams.session);
+  const contentKey = expectContentForSession(objectParams, session);
+  const contentValue = expectString(objectParams[contentKey], contentKey);
+  const args = [
+    'cron',
+    'edit',
+    id,
+    '--session',
+    session,
+    `--${toKebabCase(contentKey)}`,
+    contentValue
+  ];
+  return await runOpenClawCronCommand(args, context);
+};
+
+export const updateCronMessage: MethodHandler = async (params, context): Promise<JsonValue> => {
+  const objectParams = expectObject(params);
+  const id = expectString(objectParams.id, 'id');
+  const message = expectString(objectParams.message, 'message');
+  return await runOpenClawCronCommand([
+    'cron',
+    'edit',
+    id,
+    '--session',
+    'isolated',
+    '--message',
+    message
+  ], context);
+};
+
+export const updateCronSystemEvent: MethodHandler = async (params, context): Promise<JsonValue> => {
+  const objectParams = expectObject(params);
+  const id = expectString(objectParams.id, 'id');
+  const systemEvent = expectString(objectParams.systemEvent, 'systemEvent');
+  return await runOpenClawCronCommand([
+    'cron',
+    'edit',
+    id,
+    '--session',
+    'main',
+    '--system-event',
+    systemEvent
+  ], context);
+};
+
+export const enableCron: MethodHandler = async (params, context): Promise<JsonValue> => {
+  return await runCronById('enable', params, context);
+};
+
+export const disableCron: MethodHandler = async (params, context): Promise<JsonValue> => {
+  return await runCronById('disable', params, context);
+};
+
+export const runCron: MethodHandler = async (params, context): Promise<JsonValue> => {
+  return await runCronById('run', params, context);
+};
+
+export const removeCron: MethodHandler = async (params, context): Promise<JsonValue> => {
+  return await runCronById('rm', params, context);
+};
+
+async function runCronById(commandName: string, params: JsonValue | undefined, context: MethodContext): Promise<JsonValue> {
+  const objectParams = expectObject(params);
+  const id = expectString(objectParams.id, 'id');
+  return await runOpenClawCronCommand(['cron', commandName, id], context);
+}
+
+async function runOpenClawCronCommand(args: string[], context: MethodContext): Promise<JsonValue> {
+  const command = process.env.OPENCLAW_BIN || 'openclaw';
+
+  try {
+    const { stdout, stderr } = await execFileAsync(command, args, { cwd: context.projectRoot });
+    return {
+      ok: true,
+      command,
+      args,
+      stdout,
+      stderr,
+      parsed: parseJsonOutput(stdout)
+    };
+  } catch (err: any) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.internalError,
+      `OpenClaw cron command failed: ${err instanceof Error ? err.message : String(err)}`,
+      {
+        command,
+        args,
+        stdout: typeof err?.stdout === 'string' ? err.stdout : '',
+        stderr: typeof err?.stderr === 'string' ? err.stderr : ''
+      }
+    );
+  }
+}
+
+function expectObject(value: JsonValue | undefined): Record<string, JsonValue> {
+  if (!value || Array.isArray(value) || typeof value !== 'object') {
+    throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Params must be an object');
+  }
+
+  return value as Record<string, JsonValue>;
+}
+
+function expectString(value: JsonValue | undefined, fieldName: string): string {
+  if (typeof value !== 'string' || value.trim().length === 0) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.invalidParams,
+      `Field '${fieldName}' must be a non-empty string`
+    );
+  }
+
+  return value.trim();
+}
+
+function expectSession(value: JsonValue | undefined): CronSession {
+  const session = expectString(value, 'session');
+  if (session !== 'main' && session !== 'isolated') {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.invalidParams,
+      "Field 'session' must be one of: main, isolated"
+    );
+  }
+
+  return session;
+}
+
+function expectSingleSchedule(params: Record<string, JsonValue>): CronScheduleKey {
+  const keys: CronScheduleKey[] = ['at', 'every', 'cron'];
+  const present = keys.filter((key) => typeof params[key] === 'string' && String(params[key]).trim().length > 0);
+  if (present.length !== 1) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.invalidParams,
+      "Exactly one schedule field is required: 'at', 'every', or 'cron'"
+    );
+  }
+
+  return present[0];
+}
+
+function expectContentForSession(
+  params: Record<string, JsonValue>,
+  session: CronSession
+): 'message' | 'systemEvent' {
+  const requiredKey = session === 'isolated' ? 'message' : 'systemEvent';
+  const forbiddenKey = session === 'isolated' ? 'systemEvent' : 'message';
+
+  if (typeof params[requiredKey] !== 'string' || String(params[requiredKey]).trim().length === 0) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.invalidParams,
+      `Field '${requiredKey}' is required when session is '${session}'`
+    );
+  }
+
+  if (typeof params[forbiddenKey] === 'string' && String(params[forbiddenKey]).trim().length > 0) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.invalidParams,
+      `Field '${forbiddenKey}' cannot be used when session is '${session}'`
+    );
+  }
+
+  return requiredKey;
+}
+
+function appendOptionalString(args: string[], flag: string, value: JsonValue | undefined): void {
+  if (typeof value !== 'string') {
+    return;
+  }
+
+  const trimmed = value.trim();
+  if (trimmed.length > 0) {
+    args.push(flag, trimmed);
+  }
+}
+
+function appendOptionalPositiveInteger(args: string[], flag: string, value: JsonValue | undefined, fieldName: string): void {
+  if (value === undefined || value === null) {
+    return;
+  }
+
+  if (typeof value !== 'number' || !Number.isInteger(value) || value <= 0) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.invalidParams,
+      `Field '${fieldName}' must be a positive integer`
+    );
+  }
+
+  args.push(flag, String(value));
+}
+
+function appendOptionalBooleanFlag(args: string[], flag: string, value: JsonValue | undefined): void {
+  if (value === true) {
+    args.push(flag);
+  }
+}
+
+function appendOptionalTools(args: string[], value: JsonValue | undefined): void {
+  if (value === undefined || value === null) {
+    return;
+  }
+
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    if (trimmed.length > 0) {
+      args.push('--tools', trimmed);
+    }
+    return;
+  }
+
+  if (Array.isArray(value) && value.every((item) => typeof item === 'string' && item.trim().length > 0)) {
+    args.push('--tools', value.map((item) => String(item).trim()).join(','));
+    return;
+  }
+
+  throw new JsonRpcException(
+    JSON_RPC_ERRORS.invalidParams,
+    "Field 'tools' must be a non-empty string or string array"
+  );
+}
+
+function assertHasPatchArgs(args: string[], baseLength: number, message: string): void {
+  if (args.length <= baseLength) {
+    throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, message);
+  }
+}
+
+function parseJsonOutput(stdout: string): JsonValue | null {
+  const trimmed = stdout.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(trimmed) as JsonValue;
+  } catch {
+    return null;
+  }
+}
+
+function toKebabCase(value: string): string {
+  return value.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+}

package/src/admin/methods/index.ts

@@ -2,6 +2,21 @@ import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.ts';
 import type { MethodHandler } from '../types.ts';
 import { getAgents, getConfig } from './admin.ts';
 import { createAgent, deleteAgent, listAgents, updateAgent } from './agents-extended.ts';
+import {
+  addCron,
+  disableCron,
+  enableCron,
+  getCronStatus,
+  listCron,
+  listCronRuns,
+  renameCron,
+  removeCron,
+  rescheduleCron,
+  runCron,
+  setCronContent,
+  updateCronMessage,
+  updateCronSystemEvent
+} from './cron.ts';
 import {
   backupMemory,
   createMemoryBackupRecord,
@@ -49,6 +64,21 @@ const methods = new Map<string, MethodHandler>([
   
   // Config
   ['config.get', getConfig],
+
+  // Cron
+  ['cron.list', listCron],
+  ['cron.status', getCronStatus],
+  ['cron.runs', listCronRuns],
+  ['cron.add', addCron],
+  ['cron.rename', renameCron],
+  ['cron.reschedule', rescheduleCron],
+  ['cron.setContent', setCronContent],
+  ['cron.updateMessage', updateCronMessage],
+  ['cron.updateSystemEvent', updateCronSystemEvent],
+  ['cron.enable', enableCron],
+  ['cron.disable', disableCron],
+  ['cron.run', runCron],
+  ['cron.remove', removeCron],
   
   // Sessions
   ['sessions.list', listSessions],