@agentmarketpro/connector 2.0.3 → 2.0.4

package/dist/index.js

@@ -44,7 +44,12 @@ const https = __importStar(require("https"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
 const package_json_1 = require("../package.json");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+// 临时关闭连接器的技能自动安装功能，保留完整安装链路代码，后续恢复时改回 false 即可。
+const DISABLE_SKILL_AUTO_INSTALL_TEMPORARILY = true;
 // ============================================================
 // 工具函数
 // ============================================================
@@ -136,6 +141,173 @@ function parseApiUrl(url) {
         path: apiPath,
     };
 }
+function normalizeSkillKey(skill) {
+    return skill.trim().toLowerCase();
+}
+function uniqueSkillKeys(skills) {
+    const values = Array.isArray(skills)
+        ? skills
+        : typeof skills === 'string'
+            ? skills.split(',')
+            : [];
+    const unique = new Set();
+    for (const value of values) {
+        if (typeof value !== 'string')
+            continue;
+        const normalized = normalizeSkillKey(value);
+        if (normalized)
+            unique.add(normalized);
+    }
+    return Array.from(unique);
+}
+function collectInstalledSkillKeys(config) {
+    const entries = config?.skills?.entries || {};
+    const installed = new Set();
+    for (const [entryKey, value] of Object.entries(entries)) {
+        if (!value || typeof value !== 'object')
+            continue;
+        const enabled = value.enabled;
+        if (enabled !== true)
+            continue;
+        const normalized = normalizeSkillKey(entryKey.replace('@openclaw/', ''));
+        if (normalized) {
+            installed.add(normalized);
+        }
+    }
+    return Array.from(installed);
+}
+function uniquePackageNames(packages) {
+    const unique = new Set();
+    for (const packageName of packages) {
+        if (typeof packageName !== 'string')
+            continue;
+        const normalized = packageName.trim();
+        if (!normalized)
+            continue;
+        unique.add(normalized);
+    }
+    return Array.from(unique);
+}
+function getSkillEntryCandidates(skillKey, packageName) {
+    const candidates = new Set();
+    const normalizedSkillKey = normalizeSkillKey(skillKey);
+    if (normalizedSkillKey) {
+        candidates.add(normalizedSkillKey);
+    }
+    if (typeof packageName === 'string' && packageName.trim()) {
+        const trimmedPackageName = packageName.trim();
+        const normalizedPackageName = normalizeSkillKey(trimmedPackageName);
+        const packageSegments = trimmedPackageName.split('/').filter(Boolean);
+        const packageBaseName = packageSegments.length > 0
+            ? normalizeSkillKey(packageSegments[packageSegments.length - 1])
+            : '';
+        if (normalizedPackageName) {
+            candidates.add(normalizedPackageName);
+        }
+        if (packageBaseName) {
+            candidates.add(packageBaseName);
+        }
+    }
+    return Array.from(candidates);
+}
+function getSkillSlug(skill) {
+    if (typeof skill.sourceUrl === 'string' && skill.sourceUrl.trim()) {
+        try {
+            const url = new URL(skill.sourceUrl);
+            const segments = url.pathname.split('/').filter(Boolean);
+            if (segments.length >= 1) {
+                return segments[segments.length - 1];
+            }
+        }
+        catch {
+            // ignore invalid url, fall through
+        }
+    }
+    return skill.key || null;
+}
+function getCommandNameFromPackageName(packageName, skillKey) {
+    const normalizedPackageName = typeof packageName === 'string' ? packageName.trim() : '';
+    if (normalizedPackageName) {
+        const parts = normalizedPackageName.split('/').filter(Boolean);
+        if (parts.length > 0) {
+            return parts[parts.length - 1];
+        }
+    }
+    return skillKey;
+}
+function resolveOpenClawWorkspacePath(config) {
+    const workspacePathCandidates = [
+        config?.workspace,
+        config?.workspaceDir,
+        config?.workspace_path,
+        config?.workspacePath,
+        config?.paths?.workspace,
+        config?.paths?.workspaceDir,
+        config?.paths?.workspace_path,
+        config?.paths?.workspacePath,
+        process.env.OPENCLAW_WORKSPACE,
+    ];
+    for (const candidate of workspacePathCandidates) {
+        if (typeof candidate === 'string' && candidate.trim()) {
+            return path.resolve(candidate.trim());
+        }
+    }
+    return path.join(os.homedir(), '.openclaw', 'workspace');
+}
+function findInstalledSkillEntryKey(entries, skillKey, packageName) {
+    const candidates = new Set(getSkillEntryCandidates(skillKey, packageName));
+    for (const entryKey of Object.keys(entries)) {
+        const normalizedEntryKey = normalizeSkillKey(entryKey);
+        if (!candidates.has(normalizedEntryKey)) {
+            continue;
+        }
+        const entry = entries[entryKey];
+        if (entry?.enabled === true) {
+            return entryKey;
+        }
+    }
+    return null;
+}
+async function commandExists(command, env) {
+    const probeCommand = process.platform === 'win32'
+        ? `where ${command}`
+        : `command -v ${command}`;
+    try {
+        await execAsync(probeCommand, {
+            timeout: 30000,
+            windowsHide: true,
+            shell: process.platform === 'win32' ? 'cmd.exe' : '/bin/sh',
+            env,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function checkRegistryPackage(registry, packageName) {
+    const startedAt = Date.now();
+    try {
+        const url = `${registry.replace(/\/$/, '')}/${packageName.replace('/', '%2F')}`;
+        const response = await fetch(url, { method: 'GET' });
+        return {
+            packageName,
+            ok: response.ok,
+            statusCode: response.status,
+            latencyMs: Date.now() - startedAt,
+            error: response.ok ? null : `HTTP ${response.status}`,
+        };
+    }
+    catch (error) {
+        return {
+            packageName,
+            ok: false,
+            statusCode: null,
+            latencyMs: Date.now() - startedAt,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
 // ============================================================
 // Connector 核心类
 // ============================================================
@@ -150,6 +322,13 @@ class Connector {
         this.parsedApiUrl = null;
         // OpenClaw 配置
         this.openclawConfig = null;
+        this.requiredOpenClawSkills = [];
+        this.requiredOpenClawPackages = [];
+        this.requiredOpenClawSkillCatalog = [];
+        this.agentName = null;
+        this.agentDescription = null;
+        this.systemPrompt = null;
+        this.globalNpmRoot = null;
         this.config = config;
         this.isCustomMode = !!config.apiUrl;
         this.model = config.model || 'openclaw:main';
@@ -230,14 +409,559 @@ class Connector {
                 '  3. Or set environment variable: OPENCLAW_TOKEN=<YOUR_TOKEN>\n' +
                 '  4. Or use custom backend: --api-url <URL> --model <MODEL>');
         }
+        await this.loadRequiredOpenClawSkills();
+        const existingEntries = this.openclawConfig?.skills?.entries || {};
+        const installedSkillKeys = collectInstalledSkillKeys(this.openclawConfig);
+        const unresolvedRequiredSkills = this.requiredOpenClawSkills.filter((skillKey) => {
+            const catalogItem = this.requiredOpenClawSkillCatalog.find((item) => item.key === skillKey);
+            if (catalogItem && (catalogItem.packageName || catalogItem.nativePackageName || catalogItem.sourceUrl)) {
+                return false;
+            }
+            return !findInstalledSkillEntryKey(existingEntries, skillKey);
+        });
+        const blockedAutoInstallSkills = this.requiredOpenClawSkillCatalog
+            .filter((item) => !item.autoInstallAllowed)
+            .filter((item) => !findInstalledSkillEntryKey(existingEntries, item.key, item.nativePackageName || item.packageName))
+            .map((item) => item.key);
+        if (unresolvedRequiredSkills.length > 0 || blockedAutoInstallSkills.length > 0) {
+            const details = [
+                unresolvedRequiredSkills.length > 0
+                    ? `catalog package missing: ${unresolvedRequiredSkills.join(', ')}`
+                    : null,
+                blockedAutoInstallSkills.length > 0
+                    ? `auto-install disabled by platform: ${blockedAutoInstallSkills.join(', ')}`
+                    : null,
+            ].filter((value) => Boolean(value));
+            const message = `Required OpenClaw Skills cannot be auto-installed from platform catalog. ${details.join('; ')}. Update the backend skill catalog or install and enable them locally before reconnecting.`;
+            await this.reportSkillSyncStatus({
+                status: 'FAILED',
+                requiredSkills: this.requiredOpenClawSkills,
+                installedPackages: this.requiredOpenClawPackages,
+                missingPackages: this.requiredOpenClawPackages,
+                restartRequired: false,
+                message,
+                securityScan: {
+                    installedSkills: installedSkillKeys,
+                },
+            });
+            throw new Error(message);
+        }
         // 自动启用 HTTP API
         if (this.openclawConfig) {
             const configChanged = ensureHttpApiEnabled(this.openclawConfig);
             if (configChanged) {
+                await this.reportSkillSyncStatus({
+                    status: 'RESTART_REQUIRED',
+                    requiredSkills: this.requiredOpenClawSkills,
+                    installedPackages: this.requiredOpenClawPackages,
+                    missingPackages: [],
+                    restartRequired: true,
+                    message: 'OpenClaw HTTP API was enabled automatically. Restart OpenClaw before reconnecting.',
+                    securityScan: {
+                        installedSkills: collectInstalledSkillKeys(this.openclawConfig),
+                    },
+                });
                 throw new Error('Configuration updated. Please restart OpenClaw, then run this connector again.\n' +
                     'Run: openclaw restart');
             }
         }
+        const skillSyncChanged = await this.syncRequiredOpenClawSkills();
+        if (skillSyncChanged) {
+            throw new Error('Required OpenClaw Skills have been installed or enabled automatically. Please restart OpenClaw, then run this connector again.\n' +
+                'Run: openclaw restart');
+        }
+    }
+    async loadRequiredOpenClawSkills() {
+        const baseUrl = this.config.platformApiUrl || process.env.PLATFORM_API_URL || 'http://localhost:3000';
+        try {
+            const response = await fetch(`${baseUrl.replace(/\/$/, '')}/api/connector/profile`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    connectionId: this.config.connectionId,
+                    token: this.config.token,
+                }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => 'unknown error');
+                this.log('info', `⚠️  Failed to load required OpenClaw Skills: HTTP ${response.status} ${errorText}`);
+                return;
+            }
+            const payload = await response.json();
+            this.agentName = typeof payload.agentName === 'string' && payload.agentName.trim()
+                ? payload.agentName.trim()
+                : null;
+            this.agentDescription = typeof payload.agentDescription === 'string' && payload.agentDescription.trim()
+                ? payload.agentDescription.trim()
+                : null;
+            this.systemPrompt = typeof payload.systemPrompt === 'string' && payload.systemPrompt.trim()
+                ? payload.systemPrompt.trim()
+                : null;
+            this.requiredOpenClawSkills = uniqueSkillKeys(payload.openclawSkills || []);
+            this.requiredOpenClawSkillCatalog = Array.isArray(payload.openclawSkillCatalog)
+                ? payload.openclawSkillCatalog
+                    .filter((item) => Boolean(item) && typeof item.key === 'string')
+                    .map((item) => ({
+                    key: normalizeSkillKey(item.key),
+                    packageName: typeof item.packageName === 'string' && item.packageName.trim() ? item.packageName.trim() : null,
+                    nativePackageName: typeof item.nativePackageName === 'string' && item.nativePackageName.trim() ? item.nativePackageName.trim() : null,
+                    autoInstallAllowed: item.autoInstallAllowed === true,
+                    sourceUrl: typeof item.sourceUrl === 'string' && item.sourceUrl.trim() ? item.sourceUrl.trim() : null,
+                }))
+                : this.requiredOpenClawSkills.map((skillKey) => ({
+                    key: skillKey,
+                    packageName: null,
+                    nativePackageName: null,
+                    autoInstallAllowed: false,
+                    sourceUrl: null,
+                }));
+            const catalogByKey = new Map(this.requiredOpenClawSkillCatalog.map((item) => [item.key, item]));
+            this.requiredOpenClawSkillCatalog = this.requiredOpenClawSkills.map((skillKey) => {
+                const existing = catalogByKey.get(skillKey);
+                return existing || {
+                    key: skillKey,
+                    packageName: null,
+                    nativePackageName: null,
+                    autoInstallAllowed: false,
+                    sourceUrl: null,
+                };
+            });
+            this.requiredOpenClawPackages = uniquePackageNames(this.requiredOpenClawSkillCatalog.map((item) => item.packageName));
+            if (this.requiredOpenClawSkills.length > 0) {
+                this.log('info', `🧩 Required OpenClaw Skills: ${this.requiredOpenClawSkills.join(', ')}`);
+                if (this.config.skillInstallRegistry) {
+                    this.log('info', `🌏 Skill install registry: ${this.config.skillInstallRegistry}`);
+                }
+            }
+            if (this.agentName) {
+                this.log('info', `🤖 Loaded agent persona: ${this.agentName}`);
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.log('info', `⚠️  Failed to load required OpenClaw Skills: ${msg}`);
+        }
+    }
+    async reportSkillSyncStatus(payload) {
+        const baseUrl = this.config.platformApiUrl || process.env.PLATFORM_API_URL || 'http://localhost:3000';
+        try {
+            await fetch(`${baseUrl.replace(/\/$/, '')}/api/connector/sync-status`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    connectionId: this.config.connectionId,
+                    token: this.config.token,
+                    ...payload,
+                    lastSyncedAt: payload.lastSyncedAt || new Date().toISOString(),
+                }),
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.log('info', `⚠️  Failed to report skill sync status: ${msg}`);
+        }
+    }
+    async runSkillInstallPreflight(missingPackages) {
+        return {
+            preflight: {
+                checkedAt: new Date().toISOString(),
+                registry: this.config.skillInstallRegistry || process.env.OPENCLAW_SKILL_INSTALL_REGISTRY || 'https://registry.npmjs.org',
+                status: 'SKIPPED',
+                missingPackages,
+                reachablePackages: [],
+                unreachablePackages: [],
+                message: 'Skill installation uses managed fallback methods, registry preflight skipped.',
+            },
+            registryHealth: {
+                registry: this.config.skillInstallRegistry || process.env.OPENCLAW_SKILL_INSTALL_REGISTRY || 'https://registry.npmjs.org',
+                checkedAt: new Date().toISOString(),
+                status: 'UNKNOWN',
+                latencyMs: null,
+                packageResults: [],
+            },
+        };
+    }
+    getCommandEnv() {
+        return {
+            ...process.env,
+            ...(this.config.skillInstallRegistry
+                ? {
+                    npm_config_registry: this.config.skillInstallRegistry,
+                    OPENCLAW_SKILL_INSTALL_REGISTRY: this.config.skillInstallRegistry,
+                }
+                : {}),
+        };
+    }
+    async getGlobalNpmRootPath() {
+        if (this.globalNpmRoot) {
+            return this.globalNpmRoot;
+        }
+        const env = this.getCommandEnv();
+        const { stdout } = await execAsync('npm root -g', {
+            timeout: 30000,
+            windowsHide: true,
+            shell: process.platform === 'win32' ? 'cmd.exe' : '/bin/sh',
+            env,
+        });
+        this.globalNpmRoot = stdout.trim();
+        return this.globalNpmRoot;
+    }
+    getWorkspaceSkillsDir() {
+        return path.join(resolveOpenClawWorkspacePath(this.openclawConfig), 'skills');
+    }
+    async ensureSkillHubInstalled() {
+        const env = this.getCommandEnv();
+        const cliScriptPath = path.join(os.homedir(), '.skillhub', 'skills_store_cli.py');
+        if (fs.existsSync(cliScriptPath)) {
+            this.log('info', `✅ SkillHub CLI is already installed: ${cliScriptPath}`);
+            return cliScriptPath;
+        }
+        this.log('info', '📦 SkillHub CLI not found, bootstrapping via official installer (--cli-only)');
+        const command = process.platform === 'win32'
+            ? 'bash -lc "curl -fsSL https://skillhub-1388575217.cos.ap-guangzhou.myqcloud.com/install/install.sh | bash -s -- --cli-only"'
+            : 'curl -fsSL https://skillhub-1388575217.cos.ap-guangzhou.myqcloud.com/install/install.sh | bash -s -- --cli-only';
+        await execAsync(command, {
+            timeout: 180000,
+            windowsHide: true,
+            shell: process.platform === 'win32' ? 'cmd.exe' : '/bin/sh',
+            env,
+        });
+        if (!fs.existsSync(cliScriptPath)) {
+            throw new Error(`SkillHub CLI installer completed but CLI script is missing: ${cliScriptPath}`);
+        }
+        return cliScriptPath;
+    }
+    async runSkillHubInstall(skill) {
+        const env = this.getCommandEnv();
+        const cliScriptPath = await this.ensureSkillHubInstalled();
+        const skillSlug = getSkillSlug(skill);
+        if (!skillSlug) {
+            throw new Error(`Unable to resolve SkillHub slug for skill: ${skill.key}`);
+        }
+        const workspaceSkillsDir = this.getWorkspaceSkillsDir();
+        const targetSkillPath = path.join(workspaceSkillsDir, skillSlug, 'SKILL.md');
+        // 先检测是否已在 workspace 中安装
+        if (fs.existsSync(targetSkillPath)) {
+            this.log('info', `✅ Skill ${skill.key} already installed in workspace: ${skillSlug}`);
+            return true;
+        }
+        fs.mkdirSync(workspaceSkillsDir, { recursive: true });
+        const command = `python "${cliScriptPath}" install ${skillSlug} --dir "${workspaceSkillsDir}"`;
+        this.log('info', `📦 Installing OpenClaw Skill via SkillHub: ${skill.key} -> ${skillSlug}`);
+        await execAsync(command, {
+            timeout: 180000,
+            windowsHide: true,
+            shell: process.platform === 'win32' ? 'cmd.exe' : '/bin/sh',
+            env,
+        });
+        return fs.existsSync(targetSkillPath);
+    }
+    async runNpmGlobalInstall(skill) {
+        const installPackageName = skill.packageName;
+        if (!installPackageName) {
+            return false;
+        }
+        const env = this.getCommandEnv();
+        const commandName = getCommandNameFromPackageName(installPackageName, skill.key);
+        // 先检测是否已安装：命令存在且 workspace 中已有 SKILL.md
+        const skillSlug = getSkillSlug(skill) || skill.key;
+        const workspaceSkillPath = path.join(this.getWorkspaceSkillsDir(), skillSlug, 'SKILL.md');
+        const commandExistsAlready = await commandExists(commandName, env);
+        const skillInWorkspace = fs.existsSync(workspaceSkillPath);
+        if (commandExistsAlready && skillInWorkspace) {
+            this.log('info', `✅ Skill ${skill.key} already installed (command: ${commandName}, workspace: ${skillSlug})`);
+            return true;
+        }
+        this.log('info', `📦 Installing OpenClaw Skill via npm -g: ${installPackageName}`);
+        await execAsync(`npm install -g ${installPackageName}`, {
+            timeout: 300000,
+            windowsHide: true,
+            shell: process.platform === 'win32' ? 'cmd.exe' : '/bin/sh',
+            env,
+        });
+        if (await commandExists(commandName, env)) {
+            try {
+                await execAsync(`${commandName} install`, {
+                    timeout: 300000,
+                    windowsHide: true,
+                    shell: process.platform === 'win32' ? 'cmd.exe' : '/bin/sh',
+                    env,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.log('debug', `Optional post-install failed for ${commandName} install: ${message}`);
+            }
+            try {
+                await execAsync(`${commandName} install --with-deps`, {
+                    timeout: 300000,
+                    windowsHide: true,
+                    shell: process.platform === 'win32' ? 'cmd.exe' : '/bin/sh',
+                    env,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.log('debug', `Optional post-install failed for ${commandName} install --with-deps: ${message}`);
+            }
+        }
+        const syncedToWorkspace = await this.syncGlobalPackageSkillToWorkspace(skill);
+        return syncedToWorkspace || await commandExists(commandName, env);
+    }
+    async syncGlobalPackageSkillToWorkspace(skill) {
+        const installPackageName = skill.packageName;
+        if (!installPackageName) {
+            return false;
+        }
+        const skillSlug = getSkillSlug(skill);
+        if (!skillSlug) {
+            return false;
+        }
+        // 先检测是否已在 workspace 中存在
+        const workspaceTarget = path.join(this.getWorkspaceSkillsDir(), skillSlug);
+        const targetSkillMd = path.join(workspaceTarget, 'SKILL.md');
+        if (fs.existsSync(targetSkillMd)) {
+            this.log('info', `✅ Skill ${skill.key} already synced to workspace: ${skillSlug}`);
+            return true;
+        }
+        const globalNpmRoot = await this.getGlobalNpmRootPath();
+        const packageRoot = path.join(globalNpmRoot, installPackageName);
+        const candidateDirs = [
+            path.join(packageRoot, 'skills', skillSlug),
+            path.join(packageRoot, 'skills', skill.key),
+            path.join(packageRoot, 'skills', getCommandNameFromPackageName(installPackageName, skill.key)),
+        ];
+        const sourceDir = candidateDirs.find((candidate) => fs.existsSync(path.join(candidate, 'SKILL.md')));
+        if (!sourceDir) {
+            return false;
+        }
+        fs.mkdirSync(path.dirname(workspaceTarget), { recursive: true });
+        fs.rmSync(workspaceTarget, { recursive: true, force: true });
+        fs.cpSync(sourceDir, workspaceTarget, { recursive: true });
+        this.log('info', `📂 Synced packaged skill into OpenClaw workspace: ${workspaceTarget}`);
+        return true;
+    }
+    async runOpenClawNativeInstall(skill) {
+        const env = this.getCommandEnv();
+        const nativePackageName = skill.nativePackageName || skill.packageName;
+        if (!nativePackageName) {
+            return false;
+        }
+        if (!await commandExists('openclaw', env)) {
+            return false;
+        }
+        this.log('info', `📦 Installing OpenClaw Skill via native installer: ${nativePackageName}`);
+        await execAsync(`openclaw skills install ${nativePackageName}`, {
+            timeout: 180000,
+            windowsHide: true,
+            shell: process.platform === 'win32' ? 'cmd.exe' : '/bin/sh',
+            env,
+        });
+        return true;
+    }
+    async syncRequiredOpenClawSkills() {
+        if (this.requiredOpenClawSkillCatalog.length === 0 || !this.openclawConfig?._path) {
+            return false;
+        }
+        const existingEntries = this.openclawConfig.skills?.entries || {};
+        // 检测哪些技能确实需要安装（既不在 entries 中，也不在 workspace 中）
+        const missingCatalogItems = this.requiredOpenClawSkillCatalog.filter((item) => {
+            if (!item.autoInstallAllowed) {
+                return false;
+            }
+            if (!item.packageName && !item.nativePackageName && !item.sourceUrl) {
+                return false;
+            }
+            // 检查是否在 OpenClaw 配置的 entries 中
+            const entryKey = findInstalledSkillEntryKey(existingEntries, item.key, item.nativePackageName || item.packageName);
+            if (entryKey) {
+                return false;
+            }
+            // 检查是否已在 workspace 中安装
+            const skillSlug = getSkillSlug(item) || item.key;
+            const workspaceSkillPath = path.join(this.getWorkspaceSkillsDir(), skillSlug, 'SKILL.md');
+            if (fs.existsSync(workspaceSkillPath)) {
+                this.log('info', `✅ Skill ${item.key} already exists in workspace, skipping installation`);
+                return false;
+            }
+            return true;
+        });
+        const missingPackages = uniquePackageNames(missingCatalogItems.map((item) => item.packageName));
+        let changed = false;
+        let installedPackages = [];
+        const preflightResult = await this.runSkillInstallPreflight(missingPackages);
+        // 这里先短路自动安装，避免连接器在启动时主动改动本地技能环境。
+        // 后续如果需要恢复原行为，只需将 DISABLE_SKILL_AUTO_INSTALL_TEMPORARILY 改为 false，
+        // 下面完整的 npm / SkillHub / 本地兜底 / OpenClaw Native 安装逻辑都还保留着。
+        if (DISABLE_SKILL_AUTO_INSTALL_TEMPORARILY && missingCatalogItems.length > 0) {
+            const disabledSkillKeys = missingCatalogItems.map((item) => item.key);
+            const message = `Connector skill auto-install is temporarily disabled. Please install and enable required skills manually before reconnecting: ${disabledSkillKeys.join(', ')}`;
+            await this.reportSkillSyncStatus({
+                status: 'FAILED',
+                requiredSkills: this.requiredOpenClawSkills,
+                installedPackages,
+                missingPackages,
+                restartRequired: false,
+                message,
+                securityScan: {
+                    installedSkills: collectInstalledSkillKeys(this.openclawConfig),
+                },
+                skillPreflight: preflightResult.preflight,
+                registryHealth: preflightResult.registryHealth,
+            });
+            throw new Error(message);
+        }
+        if (missingPackages.length > 0) {
+            try {
+                for (const skill of missingCatalogItems) {
+                    let installed = false;
+                    const methodErrors = [];
+                    try {
+                        installed = await this.runNpmGlobalInstall(skill);
+                        if (installed) {
+                            this.log('info', `✅ Installed skill via npm global flow: ${skill.key}`);
+                        }
+                    }
+                    catch (error) {
+                        methodErrors.push(`npm_global: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                    if (!installed) {
+                        try {
+                            installed = await this.runSkillHubInstall(skill);
+                            if (installed) {
+                                this.log('info', `✅ Installed skill via SkillHub flow: ${skill.key}`);
+                            }
+                        }
+                        catch (error) {
+                            methodErrors.push(`skillhub: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                    }
+                    if (!installed) {
+                        try {
+                            installed = await this.syncGlobalPackageSkillToWorkspace(skill);
+                            if (installed) {
+                                this.log('info', `✅ Installed skill via local packaged fallback: ${skill.key}`);
+                            }
+                        }
+                        catch (error) {
+                            methodErrors.push(`local_packaged: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                    }
+                    if (!installed) {
+                        try {
+                            installed = await this.runOpenClawNativeInstall(skill);
+                            if (installed) {
+                                this.log('info', `✅ Installed skill via OpenClaw native flow: ${skill.key}`);
+                            }
+                        }
+                        catch (error) {
+                            methodErrors.push(`openclaw_native: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                    }
+                    if (!installed) {
+                        throw new Error(`All install methods failed for ${skill.key}: ${methodErrors.join(' | ')}`);
+                    }
+                    if (skill.packageName) {
+                        installedPackages.push(skill.packageName);
+                    }
+                }
+                changed = true;
+                this.log('info', '✅ Missing OpenClaw Skills installed via managed fallback flow');
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                await this.reportSkillSyncStatus({
+                    status: 'FAILED',
+                    requiredSkills: this.requiredOpenClawSkills,
+                    installedPackages,
+                    missingPackages,
+                    restartRequired: false,
+                    message: `Automatic OpenClaw Skills install failed: ${msg}`,
+                    securityScan: {
+                        installedSkills: collectInstalledSkillKeys(this.openclawConfig),
+                    },
+                    skillPreflight: preflightResult.preflight,
+                    registryHealth: preflightResult.registryHealth,
+                });
+                throw new Error(`Automatic OpenClaw Skills install failed after all methods: ${msg}`);
+            }
+            this.openclawConfig = loadOpenClawConfig();
+            if (!this.openclawConfig) {
+                return changed;
+            }
+        }
+        if (!this.openclawConfig.skills) {
+            this.openclawConfig.skills = { entries: {} };
+        }
+        if (!this.openclawConfig.skills.entries) {
+            this.openclawConfig.skills.entries = {};
+        }
+        for (const item of this.requiredOpenClawSkillCatalog) {
+            const entryKey = findInstalledSkillEntryKey(this.openclawConfig.skills.entries, item.key, item.nativePackageName || item.packageName);
+            if (!entryKey) {
+                continue;
+            }
+            const entry = this.openclawConfig.skills.entries[entryKey] || {};
+            if (entry.enabled !== true) {
+                this.openclawConfig.skills.entries[entryKey] = { ...entry, enabled: true };
+                changed = true;
+            }
+        }
+        if (changed) {
+            const configPath = this.openclawConfig._path;
+            if (!configPath) {
+                return changed;
+            }
+            const toWrite = { ...this.openclawConfig };
+            delete toWrite._path;
+            fs.writeFileSync(configPath, JSON.stringify(toWrite, null, 2), 'utf-8');
+            this.log('info', '✅ Required OpenClaw Skills have been enabled in config');
+            await this.reportSkillSyncStatus({
+                status: 'RESTART_REQUIRED',
+                requiredSkills: this.requiredOpenClawSkills,
+                installedPackages: this.requiredOpenClawPackages,
+                missingPackages: [],
+                restartRequired: true,
+                message: 'Required OpenClaw Skills were installed or enabled. Restart OpenClaw before reconnecting.',
+                securityScan: {
+                    installedSkills: collectInstalledSkillKeys(this.openclawConfig),
+                },
+                skillPreflight: preflightResult.preflight,
+                registryHealth: preflightResult.registryHealth,
+            });
+        }
+        else {
+            await this.reportSkillSyncStatus({
+                status: 'SYNCED',
+                requiredSkills: this.requiredOpenClawSkills,
+                installedPackages: this.requiredOpenClawPackages,
+                missingPackages: [],
+                restartRequired: false,
+                message: this.requiredOpenClawSkills.length > 0
+                    ? 'Required OpenClaw Skills are already installed and enabled.'
+                    : 'No OpenClaw Skills are required for this agent.',
+                securityScan: {
+                    installedSkills: collectInstalledSkillKeys(this.openclawConfig),
+                },
+                skillPreflight: {
+                    checkedAt: new Date().toISOString(),
+                    registry: this.config.skillInstallRegistry || process.env.OPENCLAW_SKILL_INSTALL_REGISTRY || 'https://registry.npmjs.org',
+                    status: 'SKIPPED',
+                    missingPackages: [],
+                    reachablePackages: [],
+                    unreachablePackages: [],
+                    message: 'No missing packages require installation.',
+                },
+                registryHealth: {
+                    registry: this.config.skillInstallRegistry || process.env.OPENCLAW_SKILL_INSTALL_REGISTRY || 'https://registry.npmjs.org',
+                    checkedAt: new Date().toISOString(),
+                    status: 'UNKNOWN',
+                    latencyMs: null,
+                    packageResults: [],
+                },
+            });
+        }
+        return changed;
     }
     // ============================================================
     // WebSocket 连接
@@ -303,7 +1027,12 @@ class Connector {
                 case 'pong':
                     break;
                 case 'message':
-                    await this.handleUserMessage(message.payload);
+                    if (message.payload?.type === 'HIVE_TASK') {
+                        await this.handleHiveTaskMessage(message.payload);
+                    }
+                    else {
+                        await this.handleUserMessage(message.payload);
+                    }
                     break;
                 case 'error':
                     this.log('error', `❌ Platform error: ${message.message}`);
@@ -374,6 +1103,189 @@ class Connector {
         }
         await this.callAiBackend(sessionId, messageId, content);
     }
+    async handleHiveTaskMessage(payload) {
+        const taskTitle = payload.title || '未命名任务';
+        this.log('info', '');
+        this.log('info', `📥 Hive task [${payload.taskId}]: ${taskTitle}`);
+        if (!payload.taskId || !payload.content) {
+            this.log('error', '❌ Hive task payload is invalid');
+            return;
+        }
+        if (!this.isAiReady) {
+            await this.reportHiveTaskEvent(payload, 'FAILED', {
+                summary: 'AI backend is not ready yet',
+                content: 'AI backend is not ready yet. Please try again later.',
+            });
+            return;
+        }
+        await this.reportHiveTaskEvent(payload, 'ACCEPTED', {
+            summary: `已接收任务：${taskTitle}`,
+        });
+        await this.reportHiveTaskEvent(payload, 'RUNNING', {
+            summary: `正在执行：${taskTitle}`,
+        });
+        try {
+            const finalContent = await this.generateAiCompletion(payload.content);
+            const cleanedContent = finalContent.replace(/<final>/g, '').trim();
+            if (!cleanedContent) {
+                throw new Error('No content generated');
+            }
+            await this.reportHiveTaskEvent(payload, 'DONE', {
+                summary: this.buildHiveTaskSummary(cleanedContent),
+                content: cleanedContent,
+            });
+            this.log('info', `✅ Hive task completed: ${payload.taskId}`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.log('error', `❌ Hive task failed: ${message}`);
+            await this.reportHiveTaskEvent(payload, 'FAILED', {
+                summary: message,
+                content: message,
+            });
+        }
+    }
+    buildHiveTaskSummary(content) {
+        const normalized = content.replace(/\s+/g, ' ').trim();
+        if (normalized.length <= 120) {
+            return normalized;
+        }
+        return `${normalized.slice(0, 117)}...`;
+    }
+    async reportHiveTaskEvent(payload, event, options) {
+        const baseUrl = (this.config.platformApiUrl || payload.platformApiUrl || process.env.PLATFORM_API_URL || 'http://localhost:3000').replace(/\/$/, '');
+        const callbackAuthToken = payload.callbackAuthToken;
+        if (!callbackAuthToken) {
+            throw new Error(`Missing callbackAuthToken for Hive task ${payload.taskId}`);
+        }
+        const response = await fetch(`${baseUrl}/api/internal/hive-agent-events`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${callbackAuthToken}`,
+            },
+            body: JSON.stringify({
+                taskId: payload.taskId,
+                event,
+                summary: options.summary,
+                content: options.content,
+            }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => 'unknown error');
+            throw new Error(`Failed to report Hive task event ${event}: HTTP ${response.status} ${errorText}`);
+        }
+        this.log('info', `📨 Hive task event ${event} reported to ${baseUrl}`);
+    }
+    async generateAiCompletion(content) {
+        const postData = JSON.stringify({
+            model: this.model,
+            messages: this.buildChatMessages(content),
+            stream: true,
+            user: `agentmarket-hive-${this.config.connectionId}`,
+        });
+        return new Promise((resolve, reject) => {
+            let options;
+            let reqModule;
+            if (this.isCustomMode && this.parsedApiUrl) {
+                reqModule = this.parsedApiUrl.protocol === 'https:' ? https : http;
+                options = {
+                    hostname: this.parsedApiUrl.hostname,
+                    port: this.parsedApiUrl.port,
+                    path: this.parsedApiUrl.path,
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Content-Length': Buffer.byteLength(postData),
+                        ...(this.config.apiKey ? { 'Authorization': `Bearer ${this.config.apiKey}` } : {}),
+                    },
+                    timeout: 120000,
+                };
+            }
+            else {
+                reqModule = http;
+                options = {
+                    hostname: 'localhost',
+                    port: this.openclawPort,
+                    path: '/v1/chat/completions',
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${this.openclawToken}`,
+                        'Content-Length': Buffer.byteLength(postData),
+                    },
+                    timeout: 120000,
+                };
+            }
+            const req = reqModule.request(options, (res) => {
+                const isStream = res.headers['content-type']?.includes('text/event-stream') ||
+                    res.headers['transfer-encoding'] === 'chunked';
+                if (isStream) {
+                    this.collectStreamResponse(res, resolve, reject);
+                }
+                else {
+                    this.collectNormalResponse(res, resolve, reject);
+                }
+            });
+            req.on('error', (error) => {
+                reject(new Error(`HTTP request failed: ${error.message}`));
+            });
+            req.on('timeout', () => {
+                req.destroy();
+                reject(new Error('Request timed out'));
+            });
+            req.write(postData);
+            req.end();
+        });
+    }
+    collectStreamResponse(res, resolve, reject) {
+        let fullContent = '';
+        let buffer = '';
+        res.on('data', (chunk) => {
+            buffer += chunk.toString();
+            const lines = buffer.split('\n').map(line => line.replace(/\r$/, ''));
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.startsWith('data: '))
+                    continue;
+                const data = line.slice(6).trim();
+                if (data === '[DONE]')
+                    continue;
+                try {
+                    const parsed = JSON.parse(data);
+                    const delta = parsed.choices?.[0]?.delta?.content;
+                    if (delta) {
+                        fullContent += delta;
+                    }
+                }
+                catch {
+                    // 忽略无法解析的 SSE 片段
+                }
+            }
+        });
+        res.on('end', () => resolve(fullContent));
+        res.on('error', (error) => reject(new Error(`Stream read error: ${error.message}`)));
+    }
+    collectNormalResponse(res, resolve, reject) {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+            try {
+                const result = JSON.parse(data);
+                if (result.error) {
+                    reject(new Error(typeof result.error === 'string' ? result.error : JSON.stringify(result.error)));
+                    return;
+                }
+                const replyContent = result.choices?.[0]?.message?.content || '';
+                resolve(replyContent);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                reject(new Error(`Failed to parse response: ${message}`));
+            }
+        });
+        res.on('error', (error) => reject(new Error(`Response read error: ${error.message}`)));
+    }
     // ============================================================
     // AI 后端调用（流式）
     // ============================================================
@@ -382,7 +1294,7 @@ class Connector {
         return new Promise((resolve) => {
             const postData = JSON.stringify({
                 model: this.model,
-                messages: [{ role: 'user', content }],
+                messages: this.buildChatMessages(content),
                 stream: true,
                 user: `agentmarket-${sessionId}`,
             });
@@ -575,6 +1487,38 @@ class Connector {
             console.log(`${timestamp} ${prefix} ${message}`);
         }
     }
+    buildChatMessages(content) {
+        const messages = [];
+        const systemInstruction = this.buildSystemInstruction();
+        if (systemInstruction) {
+            messages.push({ role: 'system', content: systemInstruction });
+        }
+        messages.push({ role: 'user', content });
+        return messages;
+    }
+    buildSystemInstruction() {
+        const promptParts = [];
+        if (this.systemPrompt) {
+            promptParts.push(this.systemPrompt);
+        }
+        else {
+            const identityParts = [];
+            if (this.agentName) {
+                identityParts.push(`你是「${this.agentName}」`);
+            }
+            if (this.agentDescription) {
+                identityParts.push(`角色说明：${this.agentDescription}`);
+            }
+            if (identityParts.length > 0) {
+                promptParts.push(identityParts.join('\n'));
+            }
+        }
+        if (promptParts.length === 0) {
+            return null;
+        }
+        promptParts.push('你必须始终以该智能体的角色、职责边界和风格回复用户，不要脱离设定。');
+        return promptParts.join('\n\n');
+    }
     printStartInfo() {
         const gatewayUrl = this.config.gatewayUrl || 'wss://gateway.agentmarketpro.ai/ws/connector';
         console.log('');
@@ -585,6 +1529,9 @@ class Connector {
         console.log('📋 Configuration:');
         console.log(`   ├── Gateway:       ${gatewayUrl}`);
         console.log(`   ├── Connection ID: ${this.config.connectionId}`);
+        if (this.agentName) {
+            console.log(`   ├── Agent:         ${this.agentName}`);
+        }
         if (this.isCustomMode) {
             const keyPreview = this.config.apiKey
                 ? `${this.config.apiKey.substring(0, 6)}...`
@@ -601,7 +1548,25 @@ class Connector {
                 : process.env.OPENCLAW_TOKEN ? 'env'
                     : 'auto';
             console.log(`   ├── OpenClaw:      localhost:${this.openclawPort} (HTTP API)`);
-            console.log(`   └── Token:         ${tokenPreview} (${tokenSource})`);
+            if (this.requiredOpenClawSkills.length > 0) {
+                console.log(`   ├── Skills:        ${this.requiredOpenClawSkills.join(', ')}`);
+                if (this.systemPrompt || this.agentDescription) {
+                    console.log('   ├── Persona:       loaded');
+                    console.log(`   └── Token:         ${tokenPreview} (${tokenSource})`);
+                }
+                else {
+                    console.log(`   └── Token:         ${tokenPreview} (${tokenSource})`);
+                }
+            }
+            else {
+                if (this.systemPrompt || this.agentDescription) {
+                    console.log('   ├── Persona:       loaded');
+                    console.log(`   └── Token:         ${tokenPreview} (${tokenSource})`);
+                }
+                else {
+                    console.log(`   └── Token:         ${tokenPreview} (${tokenSource})`);
+                }
+            }
         }
         console.log('');
     }