openclaw-vchat-plugin 0.0.7 → 0.0.9

package/src/services/skills.service.ts

@@ -0,0 +1,175 @@
+import path from 'path';
+import fs from 'fs';
+import { GatewayClient } from '../gateway-client';
+
+const OPENCLAW_HOME = process.env.OPENCLAW_HOME || path.join(process.env.HOME || '/root', '.openclaw');
+const OPENCLAW_CONFIG = process.env.OPENCLAW_CONFIG || path.join(OPENCLAW_HOME, 'openclaw.json');
+
+function cleanString(value: unknown): string {
+    return String(value || '').trim();
+}
+
+function toStringArray(value: unknown): string[] {
+    return Array.isArray(value)
+        ? value.map((item) => cleanString(item)).filter(Boolean)
+        : [];
+}
+
+function toInstallOptions(value: unknown): Array<{ id: string; kind: string; label: string; bins: string[] }> {
+    if (!Array.isArray(value)) return [];
+    return value
+        .map((item) => {
+            const id = cleanString((item as any)?.id);
+            if (!id) return null;
+            return {
+                id,
+                kind: cleanString((item as any)?.kind) || 'custom',
+                label: cleanString((item as any)?.label) || id,
+                bins: toStringArray((item as any)?.bins),
+            };
+        })
+        .filter((item): item is { id: string; kind: string; label: string; bins: string[] } => Boolean(item));
+}
+
+function normalizeSkillsStatus(raw: any) {
+    const managedSkillsDir = cleanString(raw?.managedSkillsDir);
+    return {
+        workspaceDir: cleanString(raw?.workspaceDir),
+        managedSkillsDir,
+        skills: (Array.isArray(raw?.skills) ? raw.skills : [])
+            .map((item: any) => ({
+                name: cleanString(item?.name),
+                description: cleanString(item?.description),
+                source: cleanString(item?.source),
+                bundled: Boolean(item?.bundled),
+                filePath: cleanString(item?.filePath),
+                baseDir: cleanString(item?.baseDir),
+                skillKey: cleanString(item?.skillKey) || cleanString(item?.name),
+                primaryEnv: cleanString(item?.primaryEnv),
+                emoji: cleanString(item?.emoji),
+                homepage: cleanString(item?.homepage),
+                always: Boolean(item?.always),
+                disabled: Boolean(item?.disabled),
+                blockedByAllowlist: Boolean(item?.blockedByAllowlist),
+                eligible: Boolean(item?.eligible),
+                requirements: {
+                    bins: toStringArray(item?.requirements?.bins),
+                    anyBins: toStringArray(item?.requirements?.anyBins),
+                    env: toStringArray(item?.requirements?.env),
+                    config: toStringArray(item?.requirements?.config),
+                    os: toStringArray(item?.requirements?.os),
+                },
+                missing: {
+                    bins: toStringArray(item?.missing?.bins),
+                    anyBins: toStringArray(item?.missing?.anyBins),
+                    env: toStringArray(item?.missing?.env),
+                    config: toStringArray(item?.missing?.config),
+                    os: toStringArray(item?.missing?.os),
+                },
+                configChecks: Array.isArray(item?.configChecks) ? item.configChecks : [],
+                install: toInstallOptions(item?.install),
+            }))
+            .filter((item: any) => item.name && item.skillKey)
+            .sort((a: any, b: any) => a.name.localeCompare(b.name, 'zh-Hans-CN')),
+    };
+}
+
+function writeConfig(config: any): void {
+    fs.mkdirSync(path.dirname(OPENCLAW_CONFIG), { recursive: true });
+    const tmpPath = `${OPENCLAW_CONFIG}.tmp`;
+    fs.writeFileSync(tmpPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+    fs.renameSync(tmpPath, OPENCLAW_CONFIG);
+}
+
+function isManagedSkillTarget(managedSkillsDir: string, targetPath: string): boolean {
+    const root = path.resolve(managedSkillsDir);
+    const target = path.resolve(targetPath);
+    if (root === target) return false;
+    const relative = path.relative(root, target);
+    return Boolean(relative) && !relative.startsWith('..') && !path.isAbsolute(relative);
+}
+
+function resolveManagedSkillTarget(skill: any, managedSkillsDir: string): string {
+    if (!managedSkillsDir || skill?.bundled) return '';
+    const baseDir = cleanString(skill?.baseDir);
+    if (baseDir && isManagedSkillTarget(managedSkillsDir, baseDir)) {
+        return path.resolve(baseDir);
+    }
+    const filePath = cleanString(skill?.filePath);
+    if (filePath && isManagedSkillTarget(managedSkillsDir, filePath)) {
+        return path.dirname(path.resolve(filePath));
+    }
+    return '';
+}
+
+export async function getSkillsStatus(gateway: GatewayClient, agentId?: string) {
+    const safeAgentId = cleanString(agentId);
+    const result = await gateway.call('skills.status', safeAgentId ? { agentId: safeAgentId } : {});
+    return normalizeSkillsStatus(result);
+}
+
+export async function installSkill(gateway: GatewayClient, params: { name: string; installId?: string; timeoutMs?: number }) {
+    const name = cleanString(params?.name);
+    if (!name) throw new Error('缺少 skill 名称');
+
+    const payload: Record<string, unknown> = { name };
+    const installId = cleanString(params?.installId);
+    if (installId) payload.installId = installId;
+
+    const timeoutMs = Number(params?.timeoutMs);
+    if (Number.isFinite(timeoutMs) && timeoutMs > 0) {
+        payload.timeoutMs = Math.max(1_000, Math.min(900_000, Math.floor(timeoutMs)));
+    }
+
+    const result = await gateway.call('skills.install', payload);
+    return {
+        ok: result?.ok === false ? false : true,
+        message: cleanString(result?.message) || '安装完成',
+        stdout: cleanString(result?.stdout),
+        stderr: cleanString(result?.stderr),
+        warnings: Array.isArray(result?.warnings) ? result.warnings : [],
+    };
+}
+
+export async function updateSkill(gateway: GatewayClient, skillKey: string, patch: { enabled?: boolean; apiKey?: string; env?: Record<string, string> }) {
+    const safeSkillKey = cleanString(skillKey);
+    if (!safeSkillKey) throw new Error('缺少 skillKey');
+
+    const payload: Record<string, unknown> = { skillKey: safeSkillKey };
+    if (typeof patch?.enabled === 'boolean') payload.enabled = patch.enabled;
+    if (typeof patch?.apiKey === 'string') payload.apiKey = patch.apiKey;
+    if (patch?.env && typeof patch.env === 'object') {
+        const envEntries = Object.entries(patch.env)
+            .map(([key, value]) => [cleanString(key), cleanString(value)] as const)
+            .filter(([key]) => Boolean(key));
+        payload.env = Object.fromEntries(envEntries);
+    }
+
+    const result = await gateway.call('skills.update', payload);
+    return {
+        ok: result?.ok === false ? false : true,
+        skillKey: cleanString(result?.skillKey) || safeSkillKey,
+        enabled: typeof result?.enabled === 'boolean' ? result.enabled : patch?.enabled,
+    };
+}
+
+export function setSkillEnabledLocally(gateway: GatewayClient, skillKey: string, enabled: boolean) {
+    const safeSkillKey = cleanString(skillKey);
+    if (!safeSkillKey) throw new Error('缺少 skillKey');
+    const config = gateway.readConfig() || {};
+    const skills = config.skills && typeof config.skills === 'object' ? { ...config.skills } : {};
+    const entries = skills.entries && typeof skills.entries === 'object' ? { ...skills.entries } : {};
+    const current = entries[safeSkillKey] && typeof entries[safeSkillKey] === 'object'
+        ? { ...entries[safeSkillKey] }
+        : {};
+    current.enabled = Boolean(enabled);
+    entries[safeSkillKey] = current;
+    skills.entries = entries;
+    config.skills = skills;
+    writeConfig(config);
+    return { ok: true, skillKey: safeSkillKey, enabled: Boolean(enabled) };
+}
+
+export function isManagedSkillInstallable(skill: any, managedSkillsDir: string): boolean {
+    return Boolean(resolveManagedSkillTarget(skill, managedSkillsDir));
+}