rol-websocket-channel 1.0.0

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

@@ -0,0 +1,191 @@
+import path from 'node:path';
+
+import { readJsonFile, writeJsonFile } from '../lib/fs.ts';
+import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.ts';
+import type { JsonValue, MethodHandler } from '../types.ts';
+
+interface OpenClawConfig {
+  models?: {
+    mode?: string;
+    providers?: Record<string, any>;
+  };
+  agents?: {
+    defaults?: {
+      model?: {
+        primary?: string;
+        provider?: string;
+        [key: string]: any;
+      };
+      [key: string]: any;
+    };
+    [key: string]: any;
+  };
+  [key: string]: any;
+}
+
+// 允许修改的 provider 配置字段白名单
+const ALLOWED_PROVIDER_FIELDS: Record<string, boolean> = {
+  'apiKey': true,
+  'baseUrl': true,
+  'model': true,
+  'temperature': true,
+  'maxTokens': true,
+  'topP': true,
+  'frequencyPenalty': true,
+  'presencePenalty': true,
+};
+
+/**
+ * 更新模型配置
+ * 支持修改 primary model 和 provider 配置
+ */
+export const updateModels: MethodHandler = async (
+  params,
+  context
+): Promise<JsonValue> => {
+  const objectParams = isObject(params) ? params : {};
+  const primaryModel = pickString(objectParams.primaryModel);
+  const modelProvider = pickString(objectParams.modelProvider);
+  const provider = pickString(objectParams.provider);
+  const providerConfig = isObject(objectParams.providerConfig) ? objectParams.providerConfig : null;
+
+  const configPath = path.join(context.openclawRoot, 'openclaw.json');
+  const config = await readJsonFile<OpenClawConfig>(configPath);
+
+  let updated = false;
+  const changes: string[] = [];
+
+  // 更新 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 = modelProvider ?? inferProviderFromPrimaryModel(primaryModel);
+    if (inferredProvider) {
+      config.agents.defaults.model.provider = inferredProvider;
+      changes.push(`Updated default model provider to: ${inferredProvider}`);
+    }
+    updated = true;
+    changes.push(`Updated primary model to: ${primaryModel}`);
+  }
+
+  if (modelProvider && !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.provider = modelProvider;
+    updated = true;
+    changes.push(`Updated default model provider to: ${modelProvider}`);
+  }
+
+  // 更新 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, modelProvider, or provider+providerConfig.'
+    );
+  }
+
+  // 写回配置文件
+  await writeJsonFile(configPath, config);
+
+  return {
+    success: true,
+    configFile: configPath,
+    changes,
+    updatedConfig: {
+      primaryModel: config.agents?.defaults?.model?.primary ?? null,
+      modelProvider: config.agents?.defaults?.model?.provider ?? null,
+      defaultModel: config.agents?.defaults?.model ?? {},
+      providers: redactSecrets(config.models?.providers ?? {})
+    }
+  };
+};
+
+function inferProviderFromPrimaryModel(primaryModel: string): string | null {
+  const slashIndex = primaryModel.indexOf('/');
+  if (slashIndex <= 0) {
+    return null;
+  }
+
+  return primaryModel.slice(0, slashIndex);
+}
+
+function pickString(value: JsonValue | undefined): string | null {
+  if (typeof value !== 'string') {
+    return null;
+  }
+
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function isObject(value: JsonValue | undefined): value is Record<string, JsonValue> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function redactSecrets(value: any): any {
+  if (Array.isArray(value)) {
+    return value.map(redactSecrets);
+  }
+
+  if (!value || typeof value !== 'object') {
+    return value;
+  }
+
+  const result: Record<string, any> = {};
+
+  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: string): boolean {
+  const normalized = key.toLowerCase();
+  return normalized.includes('apikey') || normalized.includes('token') || normalized.includes('secret');
+}
+
+function redactString(value: string): string {
+  if (value.length <= 8) {
+    return '********';
+  }
+
+  return `${value.slice(0, 4)}***${value.slice(-4)}`;
+}

package/src/admin/methods/models.ts

@@ -0,0 +1,103 @@
+import path from 'node:path';
+
+import { readJsonFile } from '../lib/fs.ts';
+import type { JsonValue, MethodHandler } from '../types.ts';
+
+interface OpenClawConfig {
+  models?: {
+    mode?: string;
+    providers?: JsonValue;
+  };
+  agents?: {
+    defaults?: {
+      model?: {
+        primary?: string;
+        provider?: string;
+        [key: string]: any;
+      };
+      [key: string]: any;
+    };
+    list?: Array<{
+      id?: string;
+      name?: string;
+      model?: {
+        primary?: string;
+        provider?: string;
+        [key: string]: any;
+      };
+      [key: string]: any;
+    }>;
+  };
+}
+
+export const getModels: MethodHandler = async (_params, context): Promise<JsonValue> => {
+  const configPath = path.join(context.openclawRoot, 'openclaw.json');
+  const config = await readJsonFile<OpenClawConfig>(configPath);
+
+  return {
+    sourceConfigFile: configPath,
+    defaults: {
+      model: config.agents?.defaults?.model ?? {}
+    },
+    agents: normalizeAgentModels(config),
+    modelConfigMode: config.models?.mode ?? null,
+    configuredProviders: redactSecrets(config.models?.providers ?? {})
+  };
+};
+
+function normalizeAgentModels(config: OpenClawConfig): JsonValue[] {
+  const items: JsonValue[] = [
+    {
+      id: 'defaults',
+      name: 'defaults',
+      model: config.agents?.defaults?.model ?? {}
+    }
+  ];
+
+  const agents = Array.isArray(config.agents?.list) ? config.agents.list : [];
+  for (const agent of agents) {
+    items.push({
+      id: agent.id ?? null,
+      name: agent.name ?? agent.id ?? null,
+      model: agent.model ?? {}
+    });
+  }
+
+  return items;
+}
+
+function redactSecrets(value: JsonValue): JsonValue {
+  if (Array.isArray(value)) {
+    return value.map(redactSecrets);
+  }
+
+  if (!value || typeof value !== 'object') {
+    return value;
+  }
+
+  const result: Record<string, JsonValue> = {};
+
+  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: string): boolean {
+  const normalized = key.toLowerCase();
+  return normalized.includes('apikey') || normalized.includes('token') || normalized.includes('secret');
+}
+
+function redactString(value: string): string {
+  if (value.length <= 8) {
+    return '********';
+  }
+
+  return `${value.slice(0, 4)}***${value.slice(-4)}`;
+}

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

@@ -0,0 +1,313 @@
+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 type { JsonValue, MethodContext, MethodHandler } from '../types.ts';
+import { findSessionRecord } from './sessions.ts';
+
+interface SessionMessage {
+  role: string;
+  content: string;
+  timestamp?: number;
+  [key: string]: any;
+}
+
+const MAX_SESSION_MESSAGES = 100;
+
+export const getSession: MethodHandler = async (
+  params,
+  context
+): Promise<JsonValue> => {
+  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: MethodHandler = async (
+  params,
+  context
+): Promise<JsonValue> => {
+  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: any = {
+    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: MethodHandler = async (
+  params,
+  context
+): Promise<JsonValue> => {
+  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: JsonValue | undefined): value is Record<string, JsonValue> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function normalizePageSize(value: number, max: number): number {
+  if (!Number.isFinite(value)) {
+    return max;
+  }
+
+  const normalized = Math.floor(value);
+  if (normalized <= 0) {
+    return max;
+  }
+
+  return Math.min(normalized, max);
+}
+
+function normalizeOffset(value: number): number {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+
+  return Math.max(0, Math.floor(value));
+}
+
+async function readSessionMessages(
+  filePath: string,
+  limit: number,
+  offset: number
+): Promise<{ total: number; items: SessionMessage[] }> {
+  if (!(await pathExists(filePath))) {
+    return { total: 0, items: [] };
+  }
+
+  const messages: SessionMessage[] = [];
+  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: MethodContext,
+  skillSlug: string
+): Promise<string | null> {
+  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: MethodContext,
+  skillSlug: string,
+  skillPath: string
+): Promise<any> {
+  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: any = { slug: skillSlug };
+
+  if (await pathExists(skillJsonPath)) {
+    metadata = await readJsonFile(skillJsonPath);
+  }
+
+  return {
+    slug: skillSlug,
+    path: skillPath,
+    content,
+    metadata
+  };
+}
+
+async function loadSkillContexts(
+  context: MethodContext,
+  skills: any[]
+): Promise<any[]> {
+  const contexts: any[] = [];
+
+  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: string, skillContexts: any[]): string {
+  const skillSections = skillContexts
+    .map((ctx) => `\n\n--- Skill: ${ctx.slug} ---\n${ctx.content}`)
+    .join('\n');
+
+  return `${message}${skillSections}`;
+}