@heybox/hb-sdk 0.3.3 → 0.4.0

package/dist/cli-chunks/doctor-WTl1HCW0.cjs

@@ -0,0 +1,186 @@
+'use strict';
+
+var fs$1 = require('node:fs');
+var fs = require('node:fs/promises');
+var os = require('node:os');
+var path = require('node:path');
+var index = require('./index-io4h3kr-.cjs');
+require('node:module');
+require('path');
+require('os');
+require('readline');
+require('tty');
+require('assert');
+require('events');
+require('stream');
+require('buffer');
+require('util');
+
+const DEFAULT_TIMEOUT_MS = 3000;
+const PACKAGE_JSON_CANDIDATES = [
+    path.resolve(__dirname, '..', 'package.json'),
+    path.resolve(__dirname, '..', '..', 'package.json'),
+    path.resolve(__dirname, '..', '..', '..', 'package.json'),
+];
+async function runDoctorCommand(runtime = {}) {
+    const logger = runtime.logger ?? index.createCliLogger();
+    const result = await logger.task('正在检查 Agent Skill 元数据', () => getDoctorResult(runtime), {
+        successText: 'Agent Skill 检查完成',
+    });
+    printDoctorResult(result, logger);
+    printDoctorNextStep(result, logger);
+    return result;
+}
+async function getDoctorResult(runtime = {}) {
+    const currentSdkVersion = await readCurrentSdkVersion(runtime.packageJsonFiles);
+    const localSkillJsonPath = resolveLocalSkillJsonPath(runtime);
+    let remoteSkill;
+    try {
+        remoteSkill = await fetchRemoteSkill(runtime);
+    }
+    catch {
+        return {
+            currentSdkVersion,
+            localSkillJsonPath,
+            status: 'REMOTE_UNAVAILABLE',
+        };
+    }
+    if (remoteSkill?.sdk?.version !== currentSdkVersion) {
+        return {
+            currentSdkVersion,
+            localSkillJsonPath,
+            remoteSkill,
+            status: 'SDK_MISMATCH',
+        };
+    }
+    const localSkill = await readLocalSkillManifest(localSkillJsonPath);
+    if (!localSkill.exists) {
+        return {
+            currentSdkVersion,
+            localSkillJsonPath,
+            remoteSkill,
+            status: 'SKILL_MISSING',
+        };
+    }
+    if (!localSkill.manifest ||
+        localSkill.manifest.name !== index.HB_SDK_SKILL_NAME ||
+        localSkill.manifest.skillVersion !== remoteSkill.version ||
+        localSkill.manifest.sdk?.version !== remoteSkill.sdk?.version) {
+        return {
+            currentSdkVersion,
+            localSkillJsonPath,
+            localSkillVersion: localSkill.manifest?.skillVersion,
+            remoteSkill,
+            status: 'SKILL_OUTDATED',
+        };
+    }
+    return {
+        currentSdkVersion,
+        localSkillJsonPath,
+        localSkillVersion: localSkill.manifest.skillVersion,
+        remoteSkill,
+        status: 'OK',
+    };
+}
+function printDoctorResult(result, logger) {
+    logger.section('Doctor');
+    logger.info(`SDK version: ${result.currentSdkVersion}`);
+    logger.info(`Remote skill: ${result.remoteSkill?.version ? `${result.remoteSkill.version} (sdk ${result.remoteSkill.sdk?.version ?? 'unknown'})` : 'unavailable'}`);
+    logger.info(`Local skill: ${result.localSkillVersion ?? 'missing'}`);
+    logger.debug(`Local skill path: ${result.localSkillJsonPath}`);
+    logger.info(`Status: ${result.status}`);
+}
+function printDoctorNextStep(result, logger) {
+    if (result.status === 'OK') {
+        logger.success('Skill is up to date.');
+        return;
+    }
+    if (result.status === 'SDK_MISMATCH') {
+        logger.warn(`Current SDK does not match the latest skill metadata. Upgrade with: npm i -D ${index.HB_SDK_PACKAGE_NAME}@latest`);
+        logger.info(`Then install or refresh the skill manually: ${formatSkillInstallCommand(result)}`);
+        return;
+    }
+    if (result.status === 'REMOTE_UNAVAILABLE') {
+        logger.warn('Remote skill metadata is unavailable. Try again later.');
+        logger.info(`Manual install command: ${index.HB_SDK_SKILL_INSTALL_COMMAND}`);
+        return;
+    }
+    logger.info(`Install or refresh the skill manually: ${formatSkillInstallCommand(result)}`);
+}
+function formatSkillInstallCommand(result) {
+    return `npx skills add ${result.remoteSkill?.source || index.HB_SDK_SKILL_SOURCE}`;
+}
+async function fetchRemoteSkill(runtime) {
+    const fetchImpl = runtime.fetchImpl ?? fetch;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), runtime.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    try {
+        const response = await fetchImpl(runtime.remoteIndexUrl ?? index.HB_SDK_SKILL_INDEX_URL, {
+            headers: {
+                accept: 'application/json',
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`remote skill index returned ${response.status}`);
+        }
+        const index$1 = (await response.json());
+        const skill = index$1.skills?.find(item => item.name === index.HB_SDK_SKILL_NAME);
+        if (!skill?.version || skill.sdk?.package !== index.HB_SDK_PACKAGE_NAME || !skill.sdk.version) {
+            throw new Error('remote hb-sdk skill metadata is incomplete');
+        }
+        return skill;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function readLocalSkillManifest(skillJsonPath) {
+    if (!(await pathExists(skillJsonPath))) {
+        return {
+            exists: false,
+        };
+    }
+    try {
+        return {
+            exists: true,
+            manifest: JSON.parse(await fs.readFile(skillJsonPath, 'utf8')),
+        };
+    }
+    catch {
+        return {
+            exists: true,
+        };
+    }
+}
+async function readCurrentSdkVersion(packageJsonCandidates = PACKAGE_JSON_CANDIDATES) {
+    for (const candidate of packageJsonCandidates) {
+        if (!(await pathExists(candidate))) {
+            continue;
+        }
+        const packageJson = JSON.parse(await fs.readFile(candidate, 'utf8'));
+        if (typeof packageJson.version === 'string' && packageJson.version) {
+            return packageJson.version;
+        }
+    }
+    throw new Error('未能读取 @heybox/hb-sdk 当前版本号');
+}
+function resolveLocalSkillJsonPath(runtime) {
+    if (runtime.localSkillJsonPath) {
+        return runtime.localSkillJsonPath;
+    }
+    const codexHome = runtime.codexHome ?? runtime.env?.CODEX_HOME ?? process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex');
+    return path.join(codexHome, 'skills', index.HB_SDK_SKILL_NAME, 'skill.json');
+}
+async function pathExists(filePath) {
+    try {
+        await fs.access(filePath, fs$1.constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+
+exports.getDoctorResult = getDoctorResult;
+exports.runDoctorCommand = runDoctorCommand;