rol-websocket-channel 1.4.2 → 1.4.8

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

@@ -1,250 +1,250 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.js';
-const execFileAsync = promisify(execFile);
-export const listCron = async (_params, context) => {
-    return await runOpenClawCronCommand(['cron', 'list'], context);
-};
-export const getCronStatus = async (_params, context) => {
-    return await runOpenClawCronCommand(['cron', 'status'], context);
-};
-export const listCronRuns = async (params, context) => {
-    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 = async (params, context) => {
-    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 = async (params, context) => {
-    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 = async (params, context) => {
-    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 = async (params, context) => {
-    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 = async (params, context) => {
-    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 = async (params, context) => {
-    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 = async (params, context) => {
-    return await runCronById('enable', params, context);
-};
-export const disableCron = async (params, context) => {
-    return await runCronById('disable', params, context);
-};
-export const runCron = async (params, context) => {
-    return await runCronById('run', params, context);
-};
-export const removeCron = async (params, context) => {
-    return await runCronById('rm', params, context);
-};
-async function runCronById(commandName, params, context) {
-    const objectParams = expectObject(params);
-    const id = expectString(objectParams.id, 'id');
-    return await runOpenClawCronCommand(['cron', commandName, id], context);
-}
-async function runOpenClawCronCommand(args, context) {
-    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) {
-        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) {
-    if (!value || Array.isArray(value) || typeof value !== 'object') {
-        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Params must be an object');
-    }
-    return value;
-}
-function expectString(value, fieldName) {
-    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) {
-    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) {
-    const keys = ['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, session) {
-    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, flag, value) {
-    if (typeof value !== 'string') {
-        return;
-    }
-    const trimmed = value.trim();
-    if (trimmed.length > 0) {
-        args.push(flag, trimmed);
-    }
-}
-function appendOptionalPositiveInteger(args, flag, value, fieldName) {
-    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, flag, value) {
-    if (value === true) {
-        args.push(flag);
-    }
-}
-function appendOptionalTools(args, value) {
-    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, baseLength, message) {
-    if (args.length <= baseLength) {
-        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, message);
-    }
-}
-function parseJsonOutput(stdout) {
-    const trimmed = stdout.trim();
-    if (!trimmed) {
-        return null;
-    }
-    try {
-        return JSON.parse(trimmed);
-    }
-    catch {
-        return null;
-    }
-}
-function toKebabCase(value) {
-    return value.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
-}
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.js';
+const execFileAsync = promisify(execFile);
+export const listCron = async (_params, context) => {
+    return await runOpenClawCronCommand(['cron', 'list'], context);
+};
+export const getCronStatus = async (_params, context) => {
+    return await runOpenClawCronCommand(['cron', 'status'], context);
+};
+export const listCronRuns = async (params, context) => {
+    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 = async (params, context) => {
+    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 = async (params, context) => {
+    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 = async (params, context) => {
+    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 = async (params, context) => {
+    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 = async (params, context) => {
+    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 = async (params, context) => {
+    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 = async (params, context) => {
+    return await runCronById('enable', params, context);
+};
+export const disableCron = async (params, context) => {
+    return await runCronById('disable', params, context);
+};
+export const runCron = async (params, context) => {
+    return await runCronById('run', params, context);
+};
+export const removeCron = async (params, context) => {
+    return await runCronById('rm', params, context);
+};
+async function runCronById(commandName, params, context) {
+    const objectParams = expectObject(params);
+    const id = expectString(objectParams.id, 'id');
+    return await runOpenClawCronCommand(['cron', commandName, id], context);
+}
+async function runOpenClawCronCommand(args, context) {
+    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) {
+        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) {
+    if (!value || Array.isArray(value) || typeof value !== 'object') {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Params must be an object');
+    }
+    return value;
+}
+function expectString(value, fieldName) {
+    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) {
+    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) {
+    const keys = ['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, session) {
+    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, flag, value) {
+    if (typeof value !== 'string') {
+        return;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length > 0) {
+        args.push(flag, trimmed);
+    }
+}
+function appendOptionalPositiveInteger(args, flag, value, fieldName) {
+    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, flag, value) {
+    if (value === true) {
+        args.push(flag);
+    }
+}
+function appendOptionalTools(args, value) {
+    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, baseLength, message) {
+    if (args.length <= baseLength) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, message);
+    }
+}
+function parseJsonOutput(stdout) {
+    const trimmed = stdout.trim();
+    if (!trimmed) {
+        return null;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+}
+function toKebabCase(value) {
+    return value.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+}