rol-websocket-channel 1.0.0

package/src/admin/lib/fs.ts

@@ -0,0 +1,35 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+export async function readJsonFile<T>(filePath: string): Promise<T> {
+  const raw = await fs.readFile(filePath, 'utf8');
+  return JSON.parse(raw) as T;
+}
+
+export async function writeJsonFile(filePath: string, data: any): Promise<void> {
+  const json = JSON.stringify(data, null, 2);
+  await fs.writeFile(filePath, json, 'utf8');
+}
+
+export async function pathExists(targetPath: string): Promise<boolean> {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function ensureDir(targetDir: string): Promise<void> {
+  await fs.mkdir(targetDir, { recursive: true });
+}
+
+export async function copyIfExists(sourcePath: string, destPath: string): Promise<boolean> {
+  if (!(await pathExists(sourcePath))) {
+    return false;
+  }
+
+  await ensureDir(path.dirname(destPath));
+  await fs.copyFile(sourcePath, destPath);
+  return true;
+}

package/src/admin/lib/paths.ts

@@ -0,0 +1,61 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.ts';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export function getProjectRoot(): string {
+  // __dirname 是 /path/to/rol-websocket-channel/src/admin/lib
+  // 需要返回 /path/to/rol-websocket-channel
+  const root = path.resolve(__dirname, '..', '..', '..');
+  console.log('[paths] __dirname:', __dirname);
+  console.log('[paths] getProjectRoot:', root);
+  return root;
+}
+
+export function getOpenClawRoot(): string {
+  if (process.env.OPENCLAW_HOME) {
+    console.log('[paths] getOpenClawRoot from env:', process.env.OPENCLAW_HOME);
+    return path.resolve(process.env.OPENCLAW_HOME);
+  }
+
+  // 插件在 ~/.openclaw/extensions/rol-websocket-channel
+  // 需要返回 ~/.openclaw
+  const projectRoot = getProjectRoot();
+  const parentDir = path.dirname(projectRoot);
+  const parentName = path.basename(parentDir);
+
+  console.log('[paths] projectRoot:', projectRoot);
+  console.log('[paths] parentDir:', parentDir);
+  console.log('[paths] parentName:', parentName);
+
+  if (parentName === 'extensions') {
+    // parentDir 是 ~/.openclaw/extensions
+    // 返回 ~/.openclaw
+    const openclawRoot = path.dirname(parentDir);
+    console.log('[paths] getOpenClawRoot (extensions):', openclawRoot);
+    return openclawRoot;
+  }
+
+  // 兜底：假设插件在 openclaw 根目录的子目录
+  const fallbackRoot = path.resolve(projectRoot, '..');
+  console.log('[paths] getOpenClawRoot (fallback):', fallbackRoot);
+  return fallbackRoot;
+}
+
+export function ensureInside(parentDir: string, targetPath: string): string {
+  const parent = path.resolve(parentDir);
+  const target = path.resolve(targetPath);
+
+  if (target !== parent && !target.startsWith(`${parent}${path.sep}`)) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.invalidParams,
+      'Path escapes allowed directory',
+      { parent, target }
+    );
+  }
+
+  return target;
+}

package/src/admin/methods/admin.ts

@@ -0,0 +1,95 @@
+import path from 'node:path';
+
+import { readJsonFile } from '../lib/fs.ts';
+import type { JsonValue, MethodHandler } from '../types.ts';
+
+interface OpenClawConfig {
+  agents?: {
+    defaults?: Record<string, JsonValue>;
+    list?: JsonValue[];
+  };
+  plugins?: {
+    allow?: string[];
+    entries?: Record<string, JsonValue>;
+  };
+  tools?: Record<string, JsonValue>;
+  gateway?: Record<string, JsonValue>;
+  session?: Record<string, JsonValue>;
+  models?: Record<string, JsonValue>;
+  skills?: Record<string, JsonValue>;
+  diagnostics?: Record<string, JsonValue>;
+  [key: string]: JsonValue | undefined;
+}
+
+export const getAgents: MethodHandler = async (_params, context): Promise<JsonValue> => {
+  const configPath = path.join(context.openclawRoot, 'openclaw.json');
+  const config = await readJsonFile<OpenClawConfig>(configPath);
+
+  return {
+    sourceConfigFile: configPath,
+    defaultAgentConfig: config.agents?.defaults ?? {},
+    namedAgents: config.agents?.list ?? [],
+    activeToolProfile: (config.tools?.profile as JsonValue | undefined) ?? null
+  };
+};
+
+export const getConfig: MethodHandler = async (params, context): Promise<JsonValue> => {
+  const configPath = path.join(context.openclawRoot, 'openclaw.json');
+  const config = await readJsonFile<OpenClawConfig>(configPath);
+  const objectParams = isObject(params) ? params : {};
+  const section = typeof objectParams.section === 'string' ? objectParams.section : null;
+
+  if (!section) {
+    return {
+      sourceConfigFile: configPath,
+      config: redactSecrets(config as unknown as JsonValue)
+    };
+  }
+
+  const value = config[section];
+  return {
+    sourceConfigFile: configPath,
+    section,
+    sectionValue: value === undefined ? null : redactSecrets(value)
+  };
+};
+
+function isObject(value: JsonValue | undefined): value is Record<string, JsonValue> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+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/agents-extended.ts

@@ -0,0 +1,310 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { pathExists, readJsonFile, writeJsonFile } from '../lib/fs.ts';
+import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.ts';
+import type { JsonValue, MethodHandler } from '../types.ts';
+
+interface OpenClawConfig {
+  agents?: {
+    defaults?: Record<string, any>;
+    list?: NamedAgentRecord[];
+  };
+  [key: string]: any;
+}
+
+interface NamedAgentRecord {
+  id: string;
+  name?: string;
+  workspace?: string;
+  agentDir?: string;
+  model?: Record<string, any>;
+  skills?: string[];
+  tools?: Record<string, any>;
+  behavior?: JsonValue;
+  [key: string]: any;
+}
+
+const ALLOWED_AGENT_UPDATES: Record<string, boolean> = {
+  'name': true,
+  'workspace': true,
+  'agentDir': true,
+  'model.primary': true,
+  'model.provider': true,
+  'skills': true,
+  'tools.profile': true,
+  'behavior': true,
+};
+
+export const listAgents: MethodHandler = async (_params, context): Promise<JsonValue> => {
+  const configPath = path.join(context.openclawRoot, 'openclaw.json');
+  const config = await loadConfig(context.openclawRoot);
+  const items = normalizeAgentList(config);
+
+  return {
+    sourceConfigFile: configPath,
+    count: items.length,
+    items
+  };
+};
+
+export const createAgent: MethodHandler = async (params, context): Promise<JsonValue> => {
+  const objectParams = expectObject(params);
+  const rawAgentId = typeof objectParams.agentId === 'string'
+    ? objectParams.agentId
+    : typeof objectParams.id === 'string'
+      ? objectParams.id
+      : undefined;
+  const agentId = sanitizeAgentId(expectString(rawAgentId, 'agentId'));
+  const configPath = path.join(context.openclawRoot, 'openclaw.json');
+  const config = await loadConfig(context.openclawRoot);
+  const agents = ensureAgentList(config);
+
+  if (findNamedAgent(agents, agentId)) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.invalidParams,
+      `Agent already exists: ${agentId}`
+    );
+  }
+
+  const workspace = typeof objectParams.workspace === 'string' && objectParams.workspace.trim().length > 0
+    ? objectParams.workspace.trim()
+    : path.join(context.openclawRoot, 'workspace', agentId);
+  const agentDir = typeof objectParams.agentDir === 'string' && objectParams.agentDir.trim().length > 0
+    ? objectParams.agentDir.trim()
+    : path.join(context.openclawRoot, 'agents', agentId, 'agent');
+
+  const created: NamedAgentRecord = {
+    id: agentId,
+    name: typeof objectParams.name === 'string' && objectParams.name.trim().length > 0
+      ? objectParams.name.trim()
+      : agentId,
+    workspace,
+    agentDir
+  };
+
+  if (typeof objectParams.modelPrimary === 'string' && objectParams.modelPrimary.trim().length > 0) {
+    created.model = { ...(created.model ?? {}), primary: objectParams.modelPrimary.trim() };
+  }
+  if (typeof objectParams.modelProvider === 'string' && objectParams.modelProvider.trim().length > 0) {
+    created.model = { ...(created.model ?? {}), provider: objectParams.modelProvider.trim() };
+  }
+  if (Array.isArray(objectParams.skills)) {
+    created.skills = objectParams.skills.filter((item): item is string => typeof item === 'string');
+  }
+  if (typeof objectParams.toolsProfile === 'string' && objectParams.toolsProfile.trim().length > 0) {
+    created.tools = { ...(created.tools ?? {}), profile: objectParams.toolsProfile.trim() };
+  }
+  if (isObject(objectParams.behavior)) {
+    created.behavior = objectParams.behavior;
+  }
+
+  agents.push(created);
+
+  await fs.mkdir(workspace, { recursive: true });
+  await fs.mkdir(agentDir, { recursive: true });
+  await writeJsonFile(configPath, config);
+
+  return {
+    success: true,
+    configFile: configPath,
+    created
+  };
+};
+
+export const deleteAgent: MethodHandler = async (params, context): Promise<JsonValue> => {
+  const objectParams = expectObject(params);
+  const rawAgentId = typeof objectParams.agentId === 'string'
+    ? objectParams.agentId
+    : typeof objectParams.id === 'string'
+      ? objectParams.id
+      : undefined;
+  const agentId = sanitizeAgentId(expectString(rawAgentId, 'agentId'));
+  const purgeFiles = objectParams.purgeFiles === true;
+
+  const configPath = path.join(context.openclawRoot, 'openclaw.json');
+  const config = await loadConfig(context.openclawRoot);
+  const agents = ensureAgentList(config);
+  const index = agents.findIndex((agent) => isMatchingAgent(agent, agentId));
+
+  if (index === -1) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.invalidParams,
+      `Agent not found: ${agentId}`
+    );
+  }
+
+  const [removed] = agents.splice(index, 1);
+  await writeJsonFile(configPath, config);
+
+  const removedPaths: string[] = [];
+  if (purgeFiles) {
+    const workspaceRoot = path.normalize(path.join(context.openclawRoot, 'workspace'));
+    const agentsRoot = path.normalize(path.join(context.openclawRoot, 'agents'));
+    const purgeCandidates = [
+      typeof removed.workspace === 'string' ? removed.workspace : null,
+      typeof removed.agentDir === 'string' ? path.dirname(removed.agentDir) : null
+    ].filter((value): value is string => Boolean(value));
+
+    for (const candidate of purgeCandidates) {
+      const normalized = path.normalize(candidate);
+      const insideWorkspace = normalized === workspaceRoot || normalized.startsWith(`${workspaceRoot}${path.sep}`);
+      const insideAgents = normalized === agentsRoot || normalized.startsWith(`${agentsRoot}${path.sep}`);
+      if (!insideWorkspace && !insideAgents) {
+        continue;
+      }
+      if (await pathExists(candidate)) {
+        await fs.rm(candidate, { recursive: true, force: true });
+        removedPaths.push(candidate);
+      }
+    }
+  }
+
+  return {
+    success: true,
+    configFile: configPath,
+    removed,
+    purgeFiles,
+    removedPaths
+  };
+};
+
+export const updateAgent: MethodHandler = async (params, context): Promise<JsonValue> => {
+  const objectParams = isObject(params) ? params : {};
+  const updates = isObject(objectParams.updates) ? objectParams.updates : null;
+  const rawAgentId = typeof objectParams.agentId === 'string'
+    ? objectParams.agentId
+    : typeof objectParams.agentName === 'string'
+      ? objectParams.agentName
+      : typeof objectParams.id === 'string'
+        ? objectParams.id
+        : 'defaults';
+  const agentId = typeof rawAgentId === 'string' && rawAgentId !== 'defaults'
+    ? sanitizeAgentId(rawAgentId)
+    : rawAgentId;
+
+  if (!updates) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.invalidParams,
+      'Missing required parameter: updates (object with field paths and values)'
+    );
+  }
+
+  const configPath = path.join(context.openclawRoot, 'openclaw.json');
+  const config = await loadConfig(context.openclawRoot);
+  const target = resolveAgentTarget(config, agentId);
+  const changes: string[] = [];
+
+  for (const [fieldPath, value] of Object.entries(updates)) {
+    if (!ALLOWED_AGENT_UPDATES[fieldPath]) {
+      throw new JsonRpcException(
+        JSON_RPC_ERRORS.invalidParams,
+        `Field not allowed for update: ${fieldPath}. Allowed fields: ${Object.keys(ALLOWED_AGENT_UPDATES).join(', ')}`
+      );
+    }
+
+    setNestedValue(target, fieldPath, value);
+    changes.push(`Updated ${fieldPath} to: ${JSON.stringify(value)}`);
+  }
+
+  await writeJsonFile(configPath, config);
+
+  return {
+    success: true,
+    configFile: configPath,
+    agentId,
+    changes,
+    updatedConfig: target
+  };
+};
+
+function setNestedValue(obj: any, pathExpression: string, value: any): void {
+  const keys = pathExpression.split('.');
+  let current = obj;
+
+  for (let index = 0; index < keys.length - 1; index += 1) {
+    const key = keys[index];
+    if (!current[key] || typeof current[key] !== 'object') {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+
+  current[keys[keys.length - 1]] = value;
+}
+
+function isObject(value: JsonValue | undefined): value is Record<string, JsonValue> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+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();
+}
+
+async function loadConfig(openclawRoot: string): Promise<OpenClawConfig> {
+  return await readJsonFile<OpenClawConfig>(path.join(openclawRoot, 'openclaw.json'));
+}
+
+function ensureAgentList(config: OpenClawConfig): NamedAgentRecord[] {
+  if (!config.agents) config.agents = {};
+  if (!Array.isArray(config.agents.list)) config.agents.list = [];
+  return config.agents.list;
+}
+
+function normalizeAgentList(config: OpenClawConfig): NamedAgentRecord[] {
+  const defaults: NamedAgentRecord = {
+    id: 'defaults',
+    name: 'defaults',
+    ...(config.agents?.defaults ?? {})
+  };
+  const named = Array.isArray(config.agents?.list) ? config.agents.list : [];
+  return [defaults, ...named];
+}
+
+function resolveAgentTarget(config: OpenClawConfig, agentName: string): Record<string, any> {
+  if (agentName === 'defaults') {
+    if (!config.agents) config.agents = {};
+    if (!config.agents.defaults) config.agents.defaults = {};
+    return config.agents.defaults;
+  }
+
+  const agents = ensureAgentList(config);
+  const found = findNamedAgent(agents, agentName);
+  if (!found) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.invalidParams,
+      `Agent not found: ${agentName}`
+    );
+  }
+  return found;
+}
+
+function findNamedAgent(agents: NamedAgentRecord[], agentName: string): NamedAgentRecord | null {
+  return agents.find((agent) => isMatchingAgent(agent, agentName)) ?? null;
+}
+
+function isMatchingAgent(agent: NamedAgentRecord, agentName: string): boolean {
+  return agent.id === agentName || agent.name === agentName;
+}
+
+function sanitizeAgentId(value: string): string {
+  return value
+    .trim()
+    .replace(/[^a-zA-Z0-9._-]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+    .toLowerCase();
+}

package/src/admin/methods/index.ts

@@ -0,0 +1,103 @@
+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 {
+  backupMemory,
+  createMemoryBackupRecord,
+  exportMemoryZip,
+  getMemoryPresignedPost,
+  getMemoryFile,
+  importMemoryZip,
+  listMemoryFiles
+} from './memory.ts';
+import { getModels } from './models.ts';
+import { updateModels } from './models-extended.ts';
+import { listSessions } from './sessions.ts';
+import { getSession, prepareMessage, attachSkill } from './sessions-extended.ts';
+import {
+  installSkillFromClawHub,
+  installSkillFromNpm,
+  listInstalledSkills,
+  searchClawHubSkills,
+  updateSkillFromClawHub
+} from './skills.ts';
+import { getInstalledSkill, uninstallSkill } from './skills-extended.ts';
+import { ping, restart, stop, doctorFix, logs } from './system.ts';
+import {
+  getUsageBreakdown,
+  getUsagePageSummary,
+  getUsageSummary,
+  getUsageTimeseries
+} from './usage.ts';
+
+const methods = new Map<string, MethodHandler>([
+  // System
+  ['system.ping', ping],
+  ['system.restart', restart],
+  ['system.stop', stop],
+  ['system.doctorFix', doctorFix],
+  ['system.logs', logs],
+  
+  // Agents
+  ['agents.get', getAgents],
+  ['agents.list', listAgents],
+  ['agents.create', createAgent],
+  ['agents.delete', deleteAgent],
+  ['agents.update', updateAgent],
+  
+  // Config
+  ['config.get', getConfig],
+  
+  // Sessions
+  ['sessions.list', listSessions],
+  ['sessions.get', getSession],
+  ['sessions.prepareMessage', prepareMessage],
+  ['sessions.attachSkill', attachSkill],
+  
+  // Models
+  ['models.get', getModels],
+  ['models.update', updateModels],
+  
+  // Usage
+  ['usage.summary', getUsageSummary],
+  ['adminBridge.usagePageSummary', getUsagePageSummary],
+  ['adminBridge.usageTimeseries', getUsageTimeseries],
+  ['adminBridge.usageBreakdown', getUsageBreakdown],
+  ['admin.usagePageSummary', getUsagePageSummary],
+  ['admin.usageTimeseries', getUsageTimeseries],
+  ['admin.usageBreakdown', getUsageBreakdown],
+  
+  // Skills
+  ['skills.listInstalled', listInstalledSkills],
+  ['skills.installFromNpm', installSkillFromNpm],
+  ['skills.searchClawHub', searchClawHubSkills],
+  ['skills.installFromClawHub', installSkillFromClawHub],
+  ['skills.updateFromClawHub', updateSkillFromClawHub],
+  ['skills.getInstalled', getInstalledSkill],
+  ['skills.uninstall', uninstallSkill],
+  
+  // Memory
+  ['memory.listFiles', listMemoryFiles],
+  ['memory.getFile', getMemoryFile],
+  ['memory.backup', backupMemory],
+  ['memory.exportZip', exportMemoryZip],
+  ['memory.getPresignedPost', getMemoryPresignedPost],
+  ['memory.createBackupRecord', createMemoryBackupRecord],
+  ['memory.importZip', importMemoryZip]
+]);
+
+export function getMethod(methodName: string): MethodHandler {
+  const handler = methods.get(methodName);
+  if (!handler) {
+    throw new JsonRpcException(JSON_RPC_ERRORS.methodNotFound, 'Method not found', {
+      method: methodName
+    });
+  }
+
+  return handler;
+}
+
+export function listMethods(): string[] {
+  return [...methods.keys()];
+}