rol-websocket-channel 1.0.0

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

@@ -0,0 +1,107 @@
+import path from 'node:path';
+import { readJsonFile, writeJsonFile } from '../lib/fs.ts';
+import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.ts';
+// 允许修改的 provider 配置字段白名单
+const ALLOWED_PROVIDER_FIELDS = {
+    'apiKey': true,
+    'baseUrl': true,
+    'model': true,
+    'temperature': true,
+    'maxTokens': true,
+    'topP': true,
+    'frequencyPenalty': true,
+    'presencePenalty': true,
+};
+/**
+ * 更新模型配置
+ * 支持修改 primary model 和 provider 配置
+ */
+export const updateModels = async (params, context) => {
+    const objectParams = isObject(params) ? params : {};
+    const primaryModel = typeof objectParams.primaryModel === 'string' ? objectParams.primaryModel : null;
+    const provider = typeof objectParams.provider === 'string' ? objectParams.provider : null;
+    const providerConfig = isObject(objectParams.providerConfig) ? objectParams.providerConfig : null;
+    const configPath = path.join(context.openclawRoot, 'openclaw.json');
+    const config = await readJsonFile(configPath);
+    let updated = false;
+    const changes = [];
+    // 更新 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;
+        updated = true;
+        changes.push(`Updated primary model to: ${primaryModel}`);
+    }
+    // 更新 provider 配置
+    if (provider && providerConfig) {
+        if (!config.models)
+            config.models = {};
+        if (!config.models.providers)
+            config.models.providers = {};
+        // 验证字段白名单
+        for (const field of Object.keys(providerConfig)) {
+            if (!ALLOWED_PROVIDER_FIELDS[field]) {
+                throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, `Field not allowed for provider config: ${field}. Allowed fields: ${Object.keys(ALLOWED_PROVIDER_FIELDS).join(', ')}`);
+            }
+        }
+        // 合并配置
+        if (!config.models.providers[provider]) {
+            config.models.providers[provider] = {};
+        }
+        config.models.providers[provider] = {
+            ...config.models.providers[provider],
+            ...providerConfig
+        };
+        updated = true;
+        changes.push(`Updated provider config for: ${provider}`);
+    }
+    if (!updated) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'No valid update parameters provided. Use primaryModel or provider+providerConfig.');
+    }
+    // 写回配置文件
+    await writeJsonFile(configPath, config);
+    return {
+        success: true,
+        configFile: configPath,
+        changes,
+        updatedConfig: {
+            primaryModel: config.agents?.defaults?.model?.primary ?? null,
+            providers: redactSecrets(config.models?.providers ?? {})
+        }
+    };
+};
+function isObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function redactSecrets(value) {
+    if (Array.isArray(value)) {
+        return value.map(redactSecrets);
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    const result = {};
+    for (const [key, nestedValue] of Object.entries(value)) {
+        if (isSecretKey(key) && typeof nestedValue === 'string') {
+            result[key] = redactString(nestedValue);
+            continue;
+        }
+        result[key] = redactSecrets(nestedValue);
+    }
+    return result;
+}
+function isSecretKey(key) {
+    const normalized = key.toLowerCase();
+    return normalized.includes('apikey') || normalized.includes('token') || normalized.includes('secret');
+}
+function redactString(value) {
+    if (value.length <= 8) {
+        return '********';
+    }
+    return `${value.slice(0, 4)}***${value.slice(-4)}`;
+}

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

@@ -0,0 +1,39 @@
+import path from 'node:path';
+import { readJsonFile } from '../lib/fs.ts';
+export const getModels = async (_params, context) => {
+    const configPath = path.join(context.openclawRoot, 'openclaw.json');
+    const config = await readJsonFile(configPath);
+    return {
+        sourceConfigFile: configPath,
+        defaultAgentPrimaryModel: config.agents?.defaults?.model?.primary ?? null,
+        modelConfigMode: config.models?.mode ?? null,
+        configuredProviders: redactSecrets(config.models?.providers ?? {})
+    };
+};
+function redactSecrets(value) {
+    if (Array.isArray(value)) {
+        return value.map(redactSecrets);
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    const result = {};
+    for (const [key, nestedValue] of Object.entries(value)) {
+        if (isSecretKey(key) && typeof nestedValue === 'string') {
+            result[key] = redactString(nestedValue);
+            continue;
+        }
+        result[key] = redactSecrets(nestedValue);
+    }
+    return result;
+}
+function isSecretKey(key) {
+    const normalized = key.toLowerCase();
+    return normalized.includes('apikey') || normalized.includes('token') || normalized.includes('secret');
+}
+function redactString(value) {
+    if (value.length <= 8) {
+        return '********';
+    }
+    return `${value.slice(0, 4)}***${value.slice(-4)}`;
+}

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

@@ -0,0 +1,207 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline';
+import { pathExists, readJsonFile } from '../lib/fs.ts';
+import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.ts';
+import { findSessionRecord } from './sessions.ts';
+const MAX_SESSION_MESSAGES = 100;
+export const getSession = async (params, context) => {
+    const objectParams = isObject(params) ? params : {};
+    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 limit = normalizePageSize(requestedLimit, MAX_SESSION_MESSAGES);
+    const offset = normalizeOffset(requestedOffset);
+    if (!sessionId) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Missing required parameter: sessionId');
+    }
+    const session = await findSessionRecord(context, sessionId);
+    if (!session) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, `Session not found: ${sessionId}`);
+    }
+    const sessionFile = session.sessionFilePath ?? path.join(context.openclawRoot, 'agents', session.agentName, 'sessions', `${session.sessionId ?? sessionId}.jsonl`);
+    const messages = await readSessionMessages(sessionFile, limit, offset);
+    return {
+        agentName: session.agentName,
+        sessionId: session.sessionId ?? sessionId,
+        sessionKey: session.sessionKey,
+        updatedAt: session.updatedAt,
+        status: session.status,
+        provider: session.provider,
+        model: session.model,
+        workspaceDir: session.workspaceDir,
+        originLabel: session.originLabel,
+        chatType: session.chatType,
+        messages: {
+            total: messages.total,
+            limit,
+            offset,
+            items: messages.items
+        }
+    };
+};
+export const prepareMessage = async (params, context) => {
+    const objectParams = isObject(params) ? params : {};
+    const sessionId = typeof objectParams.sessionId === 'string' ? objectParams.sessionId : null;
+    const message = typeof objectParams.message === 'string' ? objectParams.message : null;
+    const attachedSkills = Array.isArray(objectParams.attachedSkills) ? objectParams.attachedSkills : [];
+    if (!sessionId) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Missing required parameter: sessionId');
+    }
+    if (!message) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Missing required parameter: message');
+    }
+    const session = await findSessionRecord(context, sessionId);
+    if (!session) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, `Session not found: ${sessionId}`);
+    }
+    const messageData = {
+        agentName: session.agentName,
+        sessionId: session.sessionId ?? sessionId,
+        sessionKey: session.sessionKey,
+        message,
+        timestamp: Date.now()
+    };
+    if (attachedSkills.length > 0) {
+        messageData.attachedSkills = attachedSkills;
+        const skillContexts = await loadSkillContexts(context, attachedSkills);
+        if (skillContexts.length > 0) {
+            messageData.skillContexts = skillContexts;
+            messageData.enhancedMessage = buildEnhancedMessage(message, skillContexts);
+        }
+    }
+    return {
+        success: true,
+        messageData,
+        note: 'Message data prepared. To actually send, use MQTT sender message or OpenClaw runtime API.'
+    };
+};
+export const attachSkill = async (params, context) => {
+    const objectParams = isObject(params) ? params : {};
+    const sessionId = typeof objectParams.sessionId === 'string' ? objectParams.sessionId : null;
+    const skillSlug = typeof objectParams.skillSlug === 'string' ? objectParams.skillSlug : null;
+    const message = typeof objectParams.message === 'string' ? objectParams.message : '';
+    if (!sessionId) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Missing required parameter: sessionId');
+    }
+    if (!skillSlug) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Missing required parameter: skillSlug');
+    }
+    const skillPath = await findInstalledSkill(context, skillSlug);
+    if (!skillPath) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, `Skill not installed: ${skillSlug}`);
+    }
+    const skillContext = await loadSkillContext(context, skillSlug, skillPath);
+    const enhancedMessage = message
+        ? `${message}\n\n[Attached Skill: ${skillSlug}]`
+        : `[Using Skill: ${skillSlug}]`;
+    return {
+        success: true,
+        sessionId,
+        skillSlug,
+        skillContext,
+        enhancedMessage,
+        messageData: {
+            sessionId,
+            message: enhancedMessage,
+            attachedSkills: [{ slug: skillSlug }],
+            skillContexts: [skillContext],
+            timestamp: Date.now()
+        }
+    };
+};
+function isObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function normalizePageSize(value, max) {
+    if (!Number.isFinite(value)) {
+        return max;
+    }
+    const normalized = Math.floor(value);
+    if (normalized <= 0) {
+        return max;
+    }
+    return Math.min(normalized, max);
+}
+function normalizeOffset(value) {
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    return Math.max(0, Math.floor(value));
+}
+async function readSessionMessages(filePath, limit, offset) {
+    if (!(await pathExists(filePath))) {
+        return { total: 0, items: [] };
+    }
+    const messages = [];
+    const fileStream = fs.createReadStream(filePath);
+    const rl = readline.createInterface({
+        input: fileStream,
+        crlfDelay: Infinity
+    });
+    for await (const line of rl) {
+        if (!line.trim()) {
+            continue;
+        }
+        try {
+            messages.push(JSON.parse(line));
+        }
+        catch {
+            continue;
+        }
+    }
+    return {
+        total: messages.length,
+        items: messages.slice(offset, offset + limit)
+    };
+}
+async function findInstalledSkill(context, skillSlug) {
+    const globalPath = path.join(context.openclawRoot, 'skills', skillSlug);
+    if (await pathExists(globalPath)) {
+        return globalPath;
+    }
+    const workspacePath = path.join(context.openclawRoot, 'workspace', '.openclaw', 'skills', skillSlug);
+    if (await pathExists(workspacePath)) {
+        return workspacePath;
+    }
+    return null;
+}
+async function loadSkillContext(context, skillSlug, skillPath) {
+    const skillMdPath = path.join(skillPath, 'SKILL.md');
+    let content = '';
+    if (await pathExists(skillMdPath)) {
+        content = await fs.promises.readFile(skillMdPath, 'utf-8');
+    }
+    const skillJsonPath = path.join(skillPath, 'skill.json');
+    let metadata = { slug: skillSlug };
+    if (await pathExists(skillJsonPath)) {
+        metadata = await readJsonFile(skillJsonPath);
+    }
+    return {
+        slug: skillSlug,
+        path: skillPath,
+        content,
+        metadata
+    };
+}
+async function loadSkillContexts(context, skills) {
+    const contexts = [];
+    for (const skill of skills) {
+        const skillSlug = typeof skill === 'string' ? skill : skill?.slug;
+        if (!skillSlug) {
+            continue;
+        }
+        const skillPath = await findInstalledSkill(context, skillSlug);
+        if (!skillPath) {
+            continue;
+        }
+        contexts.push(await loadSkillContext(context, skillSlug, skillPath));
+    }
+    return contexts;
+}
+function buildEnhancedMessage(message, skillContexts) {
+    const skillSections = skillContexts
+        .map((ctx) => `\n\n--- Skill: ${ctx.slug} ---\n${ctx.content}`)
+        .join('\n');
+    return `${message}${skillSections}`;
+}

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

@@ -0,0 +1,64 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathExists, readJsonFile } from '../lib/fs.ts';
+export const listSessions = async (_params, context) => {
+    const items = await listAllAgentSessions(context);
+    return {
+        count: items.length,
+        items
+    };
+};
+export async function listAllAgentSessions(context) {
+    const agentsRoot = path.join(context.openclawRoot, 'agents');
+    if (!(await pathExists(agentsRoot))) {
+        return [];
+    }
+    const agentEntries = await fs.readdir(agentsRoot, { withFileTypes: true });
+    const items = [];
+    for (const agentEntry of agentEntries) {
+        if (!agentEntry.isDirectory()) {
+            continue;
+        }
+        const agentName = agentEntry.name;
+        const sessionsPath = path.join(agentsRoot, agentName, 'sessions', 'sessions.json');
+        if (!(await pathExists(sessionsPath))) {
+            continue;
+        }
+        const sessions = await readJsonFile(sessionsPath);
+        for (const [sessionKey, entry] of Object.entries(sessions)) {
+            const sessionId = entry.sessionId ?? extractSessionIdFromFile(entry.sessionFile) ?? null;
+            items.push({
+                agentName,
+                sessionKey,
+                sessionId,
+                updatedAt: entry.updatedAt ?? null,
+                status: entry.status ?? null,
+                provider: entry.systemPromptReport?.provider ?? entry.modelProvider ?? null,
+                model: entry.systemPromptReport?.model ?? entry.model ?? null,
+                workspaceDir: entry.systemPromptReport?.workspaceDir ?? null,
+                originLabel: entry.origin?.label ?? entry.origin?.provider ?? null,
+                chatType: entry.origin?.chatType ?? null,
+                sessionFileName: entry.sessionFile ? path.basename(entry.sessionFile) : (sessionId ? `${sessionId}.jsonl` : null),
+                sessionFilePath: sessionId
+                    ? path.join(agentsRoot, agentName, 'sessions', `${sessionId}.jsonl`)
+                    : null
+            });
+        }
+    }
+    return items.sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
+}
+export async function findSessionRecord(context, sessionIdOrKey) {
+    const sessions = await listAllAgentSessions(context);
+    return sessions.find((item) => item.sessionId === sessionIdOrKey || item.sessionKey === sessionIdOrKey) ?? null;
+}
+export async function resolveSessionFile(context, sessionIdOrKey) {
+    const session = await findSessionRecord(context, sessionIdOrKey);
+    return session?.sessionFilePath ?? null;
+}
+function extractSessionIdFromFile(sessionFile) {
+    if (!sessionFile) {
+        return null;
+    }
+    const base = path.basename(sessionFile);
+    return base.endsWith('.jsonl') ? base.slice(0, -'.jsonl'.length) : base;
+}

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

@@ -0,0 +1,157 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathExists, readJsonFile, writeJsonFile } from '../lib/fs.ts';
+import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.ts';
+import { getInstalledSkillsFromCli } from './skills.ts';
+export const getInstalledSkill = async (params, context) => {
+    const objectParams = isObject(params) ? params : {};
+    const slug = typeof objectParams.slug === 'string' ? objectParams.slug : null;
+    if (!slug) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Missing required parameter: slug');
+    }
+    const skills = await getInstalledSkillsFromCli(context);
+    const skill = skills.find((item) => isObject(item) && item.slug === slug);
+    if (!skill) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, `Skill not installed: ${slug}`);
+    }
+    return skill;
+};
+export const uninstallSkill = async (params, context) => {
+    const objectParams = isObject(params) ? params : {};
+    const slug = typeof objectParams.slug === 'string' ? objectParams.slug : null;
+    const scope = typeof objectParams.scope === 'string' ? objectParams.scope : 'global';
+    if (!slug) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Missing required parameter: slug');
+    }
+    if (slug.includes('..')) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Invalid skill slug: must not contain ..');
+    }
+    const customSkill = await findCustomInstalledSkill(context, slug);
+    const skills = await getInstalledSkillsFromCli(context);
+    const skill = customSkill ?? skills.find((item) => isObject(item) && item.slug === slug);
+    if (!skill || !isObject(skill)) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, `Skill not installed: ${slug}`);
+    }
+    const skillPathValue = typeof skill.customInstallPath === 'string' ? skill.customInstallPath :
+        typeof skill.installPath === 'string' ? skill.installPath :
+            null;
+    if (!skillPathValue) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, `Skill cannot be uninstalled: ${slug}`);
+    }
+    const normalizedSkillPath = path.normalize(skillPathValue);
+    const globalSkillsRoot = path.normalize(path.join(context.openclawRoot, 'skills'));
+    const workspaceSkillsRoot = path.normalize(path.join(context.openclawRoot, 'workspace', '.openclaw', 'skills'));
+    const insideGlobal = normalizedSkillPath === globalSkillsRoot || normalizedSkillPath.startsWith(`${globalSkillsRoot}${path.sep}`);
+    const insideWorkspace = normalizedSkillPath === workspaceSkillsRoot || normalizedSkillPath.startsWith(`${workspaceSkillsRoot}${path.sep}`);
+    if (!insideGlobal && !insideWorkspace) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Invalid skill path: must be within skills directory');
+    }
+    if (!(await pathExists(skillPathValue))) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, `Skill not installed: ${slug} (scope: ${scope})`);
+    }
+    await fs.promises.rm(skillPathValue, { recursive: true, force: true });
+    await removeSkillFromDefaults(context, slug);
+    return {
+        success: true,
+        slug,
+        scope,
+        removedPath: skillPathValue,
+        message: `Skill ${slug} uninstalled successfully`
+    };
+};
+function isObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+async function findCustomInstalledSkill(context, requestedSlug) {
+    const roots = [
+        path.join(context.openclawRoot, 'skills'),
+        path.join(context.openclawRoot, 'workspace', '.openclaw', 'skills')
+    ];
+    for (const root of roots) {
+        if (!(await pathExists(root))) {
+            continue;
+        }
+        const entries = await fs.promises.readdir(root, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const installPath = path.join(root, entry.name);
+            const aliases = await collectCustomSkillAliases(installPath, entry.name);
+            if (!aliases.has(requestedSlug)) {
+                continue;
+            }
+            return {
+                slug: aliases.has(requestedSlug) ? requestedSlug : entry.name,
+                custom: true,
+                installPath
+            };
+        }
+    }
+    return null;
+}
+async function collectCustomSkillAliases(installPath, dirName) {
+    const aliases = new Set([dirName, sanitizeAlias(dirName)]);
+    const skillJsonPath = path.join(installPath, 'skill.json');
+    const packageJsonPath = path.join(installPath, 'package.json');
+    const installMetaPath = path.join(installPath, '.openclaw-admin-bridge-install.json');
+    if (await pathExists(skillJsonPath)) {
+        const skillJson = await readJsonFile(skillJsonPath);
+        if (typeof skillJson.slug === 'string')
+            aliases.add(skillJson.slug);
+        if (typeof skillJson.name === 'string')
+            aliases.add(skillJson.name);
+    }
+    if (await pathExists(packageJsonPath)) {
+        const packageJson = await readJsonFile(packageJsonPath);
+        if (typeof packageJson.name === 'string') {
+            aliases.add(packageJson.name);
+            const lastSegment = packageJson.name.includes('/') ? (packageJson.name.split('/').at(-1) ?? packageJson.name) : packageJson.name;
+            aliases.add(lastSegment);
+            aliases.add(sanitizeAlias(lastSegment));
+        }
+    }
+    if (await pathExists(installMetaPath)) {
+        const installMeta = await readJsonFile(installMetaPath);
+        if (typeof installMeta.package === 'string') {
+            aliases.add(installMeta.package);
+            const lastSegment = installMeta.package.includes('/') ? (installMeta.package.split('/').at(-1) ?? installMeta.package) : installMeta.package;
+            aliases.add(lastSegment);
+            aliases.add(sanitizeAlias(lastSegment));
+        }
+    }
+    return aliases;
+}
+function sanitizeAlias(value) {
+    return value
+        .replace(/^@/, '')
+        .replace(/[\\/]/g, '-')
+        .replace(/[^a-zA-Z0-9._-]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .toLowerCase();
+}
+async function removeSkillFromDefaults(context, slug) {
+    const configPath = path.join(context.openclawRoot, 'openclaw.json');
+    if (!(await pathExists(configPath))) {
+        return;
+    }
+    const config = await readJsonFile(configPath);
+    const currentSkills = config.agents?.defaults?.skills;
+    if (!Array.isArray(currentSkills)) {
+        return;
+    }
+    const nextSkills = currentSkills.filter((item) => item !== slug);
+    if (nextSkills.length === currentSkills.length) {
+        return;
+    }
+    if (!config.agents)
+        config.agents = {};
+    if (!config.agents.defaults)
+        config.agents.defaults = {};
+    config.agents.defaults.skills = nextSkills;
+    await writeJsonFile(configPath, config);
+}
+function pickString(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
+}