rol-websocket-channel 1.0.0

package/src/admin/methods/sessions.ts

@@ -0,0 +1,122 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { pathExists, readJsonFile } from '../lib/fs.ts';
+import type { JsonValue, MethodContext, MethodHandler } from '../types.ts';
+
+interface SessionsIndexEntry {
+  sessionId?: string;
+  updatedAt?: number;
+  status?: string;
+  sessionFile?: string;
+  model?: string;
+  modelProvider?: string;
+  systemPromptReport?: {
+    provider?: string;
+    model?: string;
+    workspaceDir?: string;
+  };
+  origin?: {
+    label?: string;
+    provider?: string;
+    chatType?: string;
+  };
+}
+
+type SessionsIndex = Record<string, SessionsIndexEntry>;
+
+export interface AgentSessionRecord {
+  agentName: string;
+  sessionKey: string;
+  sessionId: string | null;
+  updatedAt: number | null;
+  status: string | null;
+  provider: string | null;
+  model: string | null;
+  workspaceDir: string | null;
+  originLabel: string | null;
+  chatType: string | null;
+  sessionFileName: string | null;
+  sessionFilePath: string | null;
+}
+
+export const listSessions: MethodHandler = async (
+  _params,
+  context
+): Promise<JsonValue> => {
+  const items = await listAllAgentSessions(context);
+  return {
+    count: items.length,
+    items
+  };
+};
+
+export async function listAllAgentSessions(context: MethodContext): Promise<AgentSessionRecord[]> {
+  const agentsRoot = path.join(context.openclawRoot, 'agents');
+  if (!(await pathExists(agentsRoot))) {
+    return [];
+  }
+
+  const agentEntries = await fs.readdir(agentsRoot, { withFileTypes: true });
+  const items: AgentSessionRecord[] = [];
+
+  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<SessionsIndex>(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: MethodContext,
+  sessionIdOrKey: string
+): Promise<AgentSessionRecord | null> {
+  const sessions = await listAllAgentSessions(context);
+  return sessions.find((item) => item.sessionId === sessionIdOrKey || item.sessionKey === sessionIdOrKey) ?? null;
+}
+
+export async function resolveSessionFile(
+  context: MethodContext,
+  sessionIdOrKey: string
+): Promise<string | null> {
+  const session = await findSessionRecord(context, sessionIdOrKey);
+  return session?.sessionFilePath ?? null;
+}
+
+function extractSessionIdFromFile(sessionFile: string | undefined): string | null {
+  if (!sessionFile) {
+    return null;
+  }
+
+  const base = path.basename(sessionFile);
+  return base.endsWith('.jsonl') ? base.slice(0, -'.jsonl'.length) : base;
+}

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

@@ -0,0 +1,249 @@
+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 type { JsonValue, MethodContext, MethodHandler } from '../types.ts';
+import { getInstalledSkillsFromCli } from './skills.ts';
+
+interface OpenClawConfig {
+  agents?: {
+    defaults?: {
+      skills?: string[];
+      [key: string]: unknown;
+    };
+    [key: string]: unknown;
+  };
+  [key: string]: unknown;
+}
+
+interface InstalledSkillRecord {
+  slug: string;
+  name: string;
+  version: string;
+  description?: string;
+  author?: string;
+  tags?: string[];
+  entryFile?: string;
+  npmPackage?: string;
+  installPath: string;
+  scope: 'global' | 'workspace';
+  enabled: boolean;
+}
+
+export const getInstalledSkill: MethodHandler = async (
+  params,
+  context
+): Promise<JsonValue> => {
+  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: MethodHandler = async (
+  params,
+  context
+): Promise<JsonValue> => {
+  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: JsonValue | undefined): value is Record<string, JsonValue> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+async function findCustomInstalledSkill(
+  context: MethodContext,
+  requestedSlug: string
+): Promise<Record<string, JsonValue> | null> {
+  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: string, dirName: string): Promise<Set<string>> {
+  const aliases = new Set<string>([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<Record<string, unknown>>(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<Record<string, unknown>>(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<Record<string, unknown>>(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: string): string {
+  return value
+    .replace(/^@/, '')
+    .replace(/[\\/]/g, '-')
+    .replace(/[^a-zA-Z0-9._-]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+    .toLowerCase();
+}
+
+async function removeSkillFromDefaults(context: MethodContext, slug: string): Promise<void> {
+  const configPath = path.join(context.openclawRoot, 'openclaw.json');
+  if (!(await pathExists(configPath))) {
+    return;
+  }
+
+  const config = await readJsonFile<OpenClawConfig>(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: unknown): string | undefined {
+  return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
+}

package/src/admin/methods/skills-toggle.ts

@@ -0,0 +1,235 @@
+import { readJsonFile, writeJsonFile } from '../lib/fs.ts';
+import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.ts';
+import type { JsonValue, MethodHandler } from '../types.ts';
+import { getInstalledSkillsFromCli } from './skills.ts';
+import path from 'node:path';
+
+interface OpenClawConfig {
+  agents?: {
+    defaults?: {
+      skills?: string[];
+      [key: string]: any;
+    };
+    [key: string]: any;
+  };
+  skills?: {
+    allowBundled?: string[];
+    entries?: Record<string, { enabled?: boolean;[key: string]: any }>;
+    [key: string]: any;
+  };
+  [key: string]: any;
+}
+
+interface ToggleSkillParams {
+  slug: string;
+  enabled: boolean;
+  agentName?: string;
+}
+
+/**
+ * 启用或停用 skill
+ * 通过修改 agents.defaults.skills 数组来控制
+ */
+export const toggleSkill: MethodHandler = async (
+  params,
+  context
+): Promise<JsonValue> => {
+  const objectParams = expectObject(params);
+  const slug = expectString(objectParams.slug, 'slug');
+  const enabled = expectBoolean(objectParams.enabled, 'enabled');
+  const agentName = typeof objectParams.agentName === 'string' ? objectParams.agentName : 'defaults';
+
+  if (agentName !== 'defaults') {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.invalidParams,
+      'Currently only "defaults" agent is supported'
+    );
+  }
+
+  const allSkills = await getInstalledSkillsFromCli(context);
+  const runtimeSkill = allSkills.find(
+    (item) => isObject(item) && typeof item.slug === 'string' && item.slug === slug
+  );
+  if (!runtimeSkill || !isObject(runtimeSkill)) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.invalidParams,
+      `Skill not installed: ${slug}`
+    );
+  }
+
+  const bundled = runtimeSkill.bundled === true;
+
+  const configPath = path.join(context.openclawRoot, 'openclaw.json');
+  const config = await readJsonFile<OpenClawConfig>(configPath);
+
+  if (!config.skills) config.skills = {};
+  if (!config.skills.entries) config.skills.entries = {};
+  if (!config.skills.entries[slug] || typeof config.skills.entries[slug] !== 'object') {
+    config.skills.entries[slug] = {};
+  }
+  config.skills.entries[slug].enabled = enabled;
+
+  if (bundled) {
+    if (!config.skills) config.skills = {};
+    const currentAllowBundled = Array.isArray(config.skills.allowBundled)
+      ? config.skills.allowBundled
+      : [];
+    const skillIndex = currentAllowBundled.indexOf(slug);
+
+    if (enabled) {
+      if (skillIndex === -1) {
+        currentAllowBundled.push(slug);
+        config.skills.allowBundled = currentAllowBundled;
+        await writeJsonFile(configPath, config);
+        return {
+          success: true,
+          action: 'enabled',
+          slug,
+          bundled: true,
+          skillEntry: config.skills.entries[slug],
+          allowBundled: config.skills.allowBundled
+        };
+      }
+
+      await writeJsonFile(configPath, config);
+      return {
+        success: true,
+        action: 'already_enabled',
+        slug,
+        bundled: true,
+        skillEntry: config.skills.entries[slug],
+        allowBundled: currentAllowBundled
+      };
+    }
+
+    if (skillIndex !== -1) {
+      currentAllowBundled.splice(skillIndex, 1);
+      config.skills.allowBundled = currentAllowBundled;
+      await writeJsonFile(configPath, config);
+      return {
+        success: true,
+        action: 'disabled',
+        slug,
+        bundled: true,
+        skillEntry: config.skills.entries[slug],
+        allowBundled: config.skills.allowBundled
+      };
+    }
+
+    await writeJsonFile(configPath, config);
+    return {
+      success: true,
+      action: 'already_disabled',
+      slug,
+      bundled: true,
+      skillEntry: config.skills.entries[slug],
+      allowBundled: currentAllowBundled
+    };
+  }
+
+  const installPath: string | null = (() => {
+    if (!isObject(runtimeSkill)) return null;
+    const p = runtimeSkill.installPath ?? runtimeSkill.customInstallPath;
+    return typeof p === 'string' && p.length > 0 ? p : null;
+  })();
+
+  if (!installPath) {
+    const globalSkillPath = path.join(context.openclawRoot, 'skills', slug);
+    const workspaceSkillPath = path.join(context.openclawRoot, 'workspace', '.openclaw', 'skills', slug);
+    const { pathExists } = await import('../lib/fs.ts');
+    if (!(await pathExists(globalSkillPath)) && !(await pathExists(workspaceSkillPath))) {
+      throw new JsonRpcException(
+        JSON_RPC_ERRORS.invalidParams,
+        `Skill not installed: ${slug}`
+      );
+    }
+  }
+
+  if (!config.agents) config.agents = {};
+  if (!config.agents.defaults) config.agents.defaults = {};
+  if (!config.agents.defaults.skills) config.agents.defaults.skills = [];
+
+  const currentSkills = config.agents.defaults.skills;
+  const skillIndex = currentSkills.indexOf(slug);
+
+  if (enabled) {
+    // 启用：如果不在列表中，添加
+    if (skillIndex === -1) {
+      currentSkills.push(slug);
+      await writeJsonFile(configPath, config);
+      return {
+        success: true,
+        action: 'enabled',
+        slug,
+        agentName,
+        skillEntry: config.skills.entries[slug],
+        currentSkills: config.agents.defaults.skills
+      };
+    } else {
+      await writeJsonFile(configPath, config);
+      return {
+        success: true,
+        action: 'already_enabled',
+        slug,
+        agentName,
+        skillEntry: config.skills.entries[slug],
+        currentSkills: config.agents.defaults.skills
+      };
+    }
+  } else {
+    // 停用：如果在列表中，移除
+    if (skillIndex !== -1) {
+      currentSkills.splice(skillIndex, 1);
+      await writeJsonFile(configPath, config);
+      return {
+        success: true,
+        action: 'disabled',
+        slug,
+        agentName,
+        skillEntry: config.skills.entries[slug],
+        currentSkills: config.agents.defaults.skills
+      };
+    } else {
+      await writeJsonFile(configPath, config);
+      return {
+        success: true,
+        action: 'already_disabled',
+        slug,
+        agentName,
+        skillEntry: config.skills.entries[slug],
+        currentSkills: config.agents.defaults.skills
+      };
+    }
+  }
+};
+
+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 expectBoolean(value: JsonValue | undefined, fieldName: string): boolean {
+  if (typeof value !== 'boolean') {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.invalidParams,
+      `Field '${fieldName}' must be a boolean`
+    );
+  }
+  return value;
+}
+
+function isObject(value: JsonValue | undefined): value is Record<string, JsonValue> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}